﻿using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using HslCommunication.Algorithms.ConnectPool;

namespace HslCommunication.Enthernet.Redis
{
	/// <summary>
	/// <b>[商业授权]</b> Redis客户端的连接池类对象，用于共享当前的连接池，合理的动态调整连接对象，然后进行高效通信的操作，默认连接数无限大。<br />
	/// <b>[Authorization]</b> The connection pool class object of the Redis client is used to share the current connection pool, 
	/// reasonably dynamically adjust the connection object, and then perform efficient communication operations, 
	/// The default number of connections is unlimited
	/// </summary>
	/// <remarks>
	/// 本连接池的实现仅对商业授权用户开放，用于提供服务器端的与Redis的并发读写能力。使用上和普通的 <see cref="T:HslCommunication.Enthernet.Redis.RedisClient" /> 没有区别，
	/// 但是在高并发上却高性能的多，占用的连接也更少，这一切都是连接池自动实现的。
	/// </remarks>
	// Token: 0x02000104 RID: 260
	public class RedisClientPool
	{
		/// <summary>
		/// 实例化一个默认的客户端连接池对象，需要指定实例Redis对象时的IP，端口，密码信息<br />
		/// To instantiate a default client connection pool object, you need to specify the IP, port, and password information when the Redis object is instantiated
		/// </summary>
		/// <param name="ipAddress">IP地址信息</param>
		/// <param name="port">端口号信息</param>
		/// <param name="password">密码，如果没有，请输入空字符串</param>
		// Token: 0x0600158B RID: 5515 RVA: 0x0006F844 File Offset: 0x0006DA44
		public RedisClientPool(string ipAddress, int port, string password)
		{
			bool flag = Authorization.asdniasnfaksndiqwhawfskhfaiw();
			if (flag)
			{
				this.redisConnectPool = new ConnectPool<IRedisConnector>(() => new IRedisConnector
				{
					Redis = new RedisClient(ipAddress, port, password)
				});
				this.redisConnectPool.MaxConnector = int.MaxValue;
				return;
			}
			throw new Exception(StringResources.Language.InsufficientPrivileges);
		}

		/// <summary>
		/// 实例化一个默认的客户端连接池对象，需要指定实例Redis对象时的IP，端口，密码信息，以及可以指定额外的初始化操作<br />
		/// To instantiate a default client connection pool object, you need to specify the IP, port, 
		/// and password information when the Redis object is instantiated, and you can specify additional initialization operations
		/// </summary>
		/// <param name="ipAddress">IP地址信息</param>
		/// <param name="port">端口号信息</param>
		/// <param name="password">密码，如果没有，请输入空字符串</param>
		/// <param name="initialize">额外的初始化信息，比如修改db块的信息。</param>
		// Token: 0x0600158C RID: 5516 RVA: 0x0006F8BC File Offset: 0x0006DABC
		public RedisClientPool(string ipAddress, int port, string password, Action<RedisClient> initialize)
		{
			bool flag = Authorization.asdniasnfaksndiqwhawfskhfaiw();
			if (flag)
			{
				this.redisConnectPool = new ConnectPool<IRedisConnector>(delegate()
				{
					RedisClient redisClient = new RedisClient(ipAddress, port, password);
					initialize(redisClient);
					return new IRedisConnector
					{
						Redis = redisClient
					};
				});
				this.redisConnectPool.MaxConnector = int.MaxValue;
				return;
			}
			throw new Exception(StringResources.Language.InsufficientPrivileges);
		}

		/// <summary>
		/// 获取当前的连接池管理对象信息<br />
		/// Get current connection pool management object information
		/// </summary>
		// Token: 0x17000505 RID: 1285
		// (get) Token: 0x0600158D RID: 5517 RVA: 0x0006F93A File Offset: 0x0006DB3A
		public ConnectPool<IRedisConnector> GetRedisConnectPool
		{
			get
			{
				return this.redisConnectPool;
			}
		}

		/// <inheritdoc cref="P:HslCommunication.Algorithms.ConnectPool.ConnectPool`1.MaxConnector" />
		// Token: 0x17000506 RID: 1286
		// (get) Token: 0x0600158E RID: 5518 RVA: 0x0006F942 File Offset: 0x0006DB42
		// (set) Token: 0x0600158F RID: 5519 RVA: 0x0006F94F File Offset: 0x0006DB4F
		public int MaxConnector
		{
			get
			{
				return this.redisConnectPool.MaxConnector;
			}
			set
			{
				this.redisConnectPool.MaxConnector = value;
			}
		}

		// Token: 0x06001590 RID: 5520 RVA: 0x0006F960 File Offset: 0x0006DB60
		private OperateResult<T> ConnectPoolExecute<T>(Func<RedisClient, OperateResult<T>> exec)
		{
			bool flag = Authorization.asdniasnfaksndiqwhawfskhfaiw();
			if (flag)
			{
				IRedisConnector availableConnector = this.redisConnectPool.GetAvailableConnector();
				OperateResult<T> result = exec(availableConnector.Redis);
				this.redisConnectPool.ReturnConnector(availableConnector);
				return result;
			}
			throw new Exception(StringResources.Language.InsufficientPrivileges);
		}

		// Token: 0x06001591 RID: 5521 RVA: 0x0006F9B4 File Offset: 0x0006DBB4
		private OperateResult ConnectPoolExecute(Func<RedisClient, OperateResult> exec)
		{
			bool flag = Authorization.asdniasnfaksndiqwhawfskhfaiw();
			if (flag)
			{
				IRedisConnector availableConnector = this.redisConnectPool.GetAvailableConnector();
				OperateResult result = exec(availableConnector.Redis);
				this.redisConnectPool.ReturnConnector(availableConnector);
				return result;
			}
			throw new Exception(StringResources.Language.InsufficientPrivileges);
		}

		// Token: 0x06001592 RID: 5522 RVA: 0x0006FA08 File Offset: 0x0006DC08
		[DebuggerStepThrough]
		private Task<OperateResult<T>> ConnectPoolExecuteAsync<T>(Func<RedisClient, Task<OperateResult<T>>> execAsync)
		{
			RedisClientPool.<ConnectPoolExecuteAsync>d__9<T> <ConnectPoolExecuteAsync>d__ = new RedisClientPool.<ConnectPoolExecuteAsync>d__9<T>();
			<ConnectPoolExecuteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ConnectPoolExecuteAsync>d__.<>4__this = this;
			<ConnectPoolExecuteAsync>d__.execAsync = execAsync;
			<ConnectPoolExecuteAsync>d__.<>1__state = -1;
			<ConnectPoolExecuteAsync>d__.<>t__builder.Start<RedisClientPool.<ConnectPoolExecuteAsync>d__9<T>>(ref <ConnectPoolExecuteAsync>d__);
			return <ConnectPoolExecuteAsync>d__.<>t__builder.Task;
		}

		// Token: 0x06001593 RID: 5523 RVA: 0x0006FA54 File Offset: 0x0006DC54
		[DebuggerStepThrough]
		private Task<OperateResult> ConnectPoolExecuteAsync(Func<RedisClient, Task<OperateResult>> execAsync)
		{
			RedisClientPool.<ConnectPoolExecuteAsync>d__10 <ConnectPoolExecuteAsync>d__ = new RedisClientPool.<ConnectPoolExecuteAsync>d__10();
			<ConnectPoolExecuteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ConnectPoolExecuteAsync>d__.<>4__this = this;
			<ConnectPoolExecuteAsync>d__.execAsync = execAsync;
			<ConnectPoolExecuteAsync>d__.<>1__state = -1;
			<ConnectPoolExecuteAsync>d__.<>t__builder.Start<RedisClientPool.<ConnectPoolExecuteAsync>d__10>(ref <ConnectPoolExecuteAsync>d__);
			return <ConnectPoolExecuteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteKey(System.String[])" />
		// Token: 0x06001594 RID: 5524 RVA: 0x0006FAA0 File Offset: 0x0006DCA0
		public OperateResult<int> DeleteKey(string[] keys)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.DeleteKey(keys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteKey(System.String)" />
		// Token: 0x06001595 RID: 5525 RVA: 0x0006FACC File Offset: 0x0006DCCC
		public OperateResult<int> DeleteKey(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.DeleteKey(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ExistsKey(System.String)" />
		// Token: 0x06001596 RID: 5526 RVA: 0x0006FAF8 File Offset: 0x0006DCF8
		public OperateResult<int> ExistsKey(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ExistsKey(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ExpireKey(System.String,System.Int32)" />
		// Token: 0x06001597 RID: 5527 RVA: 0x0006FB24 File Offset: 0x0006DD24
		public OperateResult<int> ExpireKey(string key, int seconds)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ExpireKey(key, seconds));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadAllKeys(System.String)" />
		// Token: 0x06001598 RID: 5528 RVA: 0x0006FB58 File Offset: 0x0006DD58
		public OperateResult<string[]> ReadAllKeys(string pattern)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ReadAllKeys(pattern));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.MoveKey(System.String,System.Int32)" />
		// Token: 0x06001599 RID: 5529 RVA: 0x0006FB84 File Offset: 0x0006DD84
		public OperateResult MoveKey(string key, int db)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.MoveKey(key, db));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.PersistKey(System.String)" />
		// Token: 0x0600159A RID: 5530 RVA: 0x0006FBB8 File Offset: 0x0006DDB8
		public OperateResult<int> PersistKey(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.PersistKey(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadRandomKey" />
		// Token: 0x0600159B RID: 5531 RVA: 0x0006FBE4 File Offset: 0x0006DDE4
		public OperateResult<string> ReadRandomKey()
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadRandomKey());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.RenameKey(System.String,System.String)" />
		// Token: 0x0600159C RID: 5532 RVA: 0x0006FC0C File Offset: 0x0006DE0C
		public OperateResult RenameKey(string key1, string key2)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.RenameKey(key1, key2));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyType(System.String)" />
		// Token: 0x0600159D RID: 5533 RVA: 0x0006FC40 File Offset: 0x0006DE40
		public OperateResult<string> ReadKeyType(string key)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadKeyType(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyTTL(System.String)" />
		// Token: 0x0600159E RID: 5534 RVA: 0x0006FC6C File Offset: 0x0006DE6C
		public OperateResult<int> ReadKeyTTL(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ReadKeyTTL(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DeleteKey(System.String[])" />
		// Token: 0x0600159F RID: 5535 RVA: 0x0006FC98 File Offset: 0x0006DE98
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteKeyAsync(string[] keys)
		{
			RedisClientPool.<DeleteKeyAsync>d__22 <DeleteKeyAsync>d__ = new RedisClientPool.<DeleteKeyAsync>d__22();
			<DeleteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteKeyAsync>d__.<>4__this = this;
			<DeleteKeyAsync>d__.keys = keys;
			<DeleteKeyAsync>d__.<>1__state = -1;
			<DeleteKeyAsync>d__.<>t__builder.Start<RedisClientPool.<DeleteKeyAsync>d__22>(ref <DeleteKeyAsync>d__);
			return <DeleteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DeleteKey(System.String)" />
		// Token: 0x060015A0 RID: 5536 RVA: 0x0006FCE4 File Offset: 0x0006DEE4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteKeyAsync(string key)
		{
			RedisClientPool.<DeleteKeyAsync>d__23 <DeleteKeyAsync>d__ = new RedisClientPool.<DeleteKeyAsync>d__23();
			<DeleteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteKeyAsync>d__.<>4__this = this;
			<DeleteKeyAsync>d__.key = key;
			<DeleteKeyAsync>d__.<>1__state = -1;
			<DeleteKeyAsync>d__.<>t__builder.Start<RedisClientPool.<DeleteKeyAsync>d__23>(ref <DeleteKeyAsync>d__);
			return <DeleteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ExistsKey(System.String)" />
		// Token: 0x060015A1 RID: 5537 RVA: 0x0006FD30 File Offset: 0x0006DF30
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ExistsKeyAsync(string key)
		{
			RedisClientPool.<ExistsKeyAsync>d__24 <ExistsKeyAsync>d__ = new RedisClientPool.<ExistsKeyAsync>d__24();
			<ExistsKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ExistsKeyAsync>d__.<>4__this = this;
			<ExistsKeyAsync>d__.key = key;
			<ExistsKeyAsync>d__.<>1__state = -1;
			<ExistsKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ExistsKeyAsync>d__24>(ref <ExistsKeyAsync>d__);
			return <ExistsKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ExpireKey(System.String,System.Int32)" />
		// Token: 0x060015A2 RID: 5538 RVA: 0x0006FD7C File Offset: 0x0006DF7C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ExpireKeyAsync(string key, int seconds)
		{
			RedisClientPool.<ExpireKeyAsync>d__25 <ExpireKeyAsync>d__ = new RedisClientPool.<ExpireKeyAsync>d__25();
			<ExpireKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ExpireKeyAsync>d__.<>4__this = this;
			<ExpireKeyAsync>d__.key = key;
			<ExpireKeyAsync>d__.seconds = seconds;
			<ExpireKeyAsync>d__.<>1__state = -1;
			<ExpireKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ExpireKeyAsync>d__25>(ref <ExpireKeyAsync>d__);
			return <ExpireKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadAllKeys(System.String)" />
		// Token: 0x060015A3 RID: 5539 RVA: 0x0006FDD0 File Offset: 0x0006DFD0
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadAllKeysAsync(string pattern)
		{
			RedisClientPool.<ReadAllKeysAsync>d__26 <ReadAllKeysAsync>d__ = new RedisClientPool.<ReadAllKeysAsync>d__26();
			<ReadAllKeysAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadAllKeysAsync>d__.<>4__this = this;
			<ReadAllKeysAsync>d__.pattern = pattern;
			<ReadAllKeysAsync>d__.<>1__state = -1;
			<ReadAllKeysAsync>d__.<>t__builder.Start<RedisClientPool.<ReadAllKeysAsync>d__26>(ref <ReadAllKeysAsync>d__);
			return <ReadAllKeysAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.MoveKey(System.String,System.Int32)" />
		// Token: 0x060015A4 RID: 5540 RVA: 0x0006FE1C File Offset: 0x0006E01C
		[DebuggerStepThrough]
		public Task<OperateResult> MoveKeyAsync(string key, int db)
		{
			RedisClientPool.<MoveKeyAsync>d__27 <MoveKeyAsync>d__ = new RedisClientPool.<MoveKeyAsync>d__27();
			<MoveKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<MoveKeyAsync>d__.<>4__this = this;
			<MoveKeyAsync>d__.key = key;
			<MoveKeyAsync>d__.db = db;
			<MoveKeyAsync>d__.<>1__state = -1;
			<MoveKeyAsync>d__.<>t__builder.Start<RedisClientPool.<MoveKeyAsync>d__27>(ref <MoveKeyAsync>d__);
			return <MoveKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.PersistKey(System.String)" />
		// Token: 0x060015A5 RID: 5541 RVA: 0x0006FE70 File Offset: 0x0006E070
		[DebuggerStepThrough]
		public Task<OperateResult<int>> PersistKeyAsync(string key)
		{
			RedisClientPool.<PersistKeyAsync>d__28 <PersistKeyAsync>d__ = new RedisClientPool.<PersistKeyAsync>d__28();
			<PersistKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<PersistKeyAsync>d__.<>4__this = this;
			<PersistKeyAsync>d__.key = key;
			<PersistKeyAsync>d__.<>1__state = -1;
			<PersistKeyAsync>d__.<>t__builder.Start<RedisClientPool.<PersistKeyAsync>d__28>(ref <PersistKeyAsync>d__);
			return <PersistKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadRandomKey" />
		// Token: 0x060015A6 RID: 5542 RVA: 0x0006FEBC File Offset: 0x0006E0BC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadRandomKeyAsync()
		{
			RedisClientPool.<ReadRandomKeyAsync>d__29 <ReadRandomKeyAsync>d__ = new RedisClientPool.<ReadRandomKeyAsync>d__29();
			<ReadRandomKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadRandomKeyAsync>d__.<>4__this = this;
			<ReadRandomKeyAsync>d__.<>1__state = -1;
			<ReadRandomKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ReadRandomKeyAsync>d__29>(ref <ReadRandomKeyAsync>d__);
			return <ReadRandomKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.RenameKey(System.String,System.String)" />
		// Token: 0x060015A7 RID: 5543 RVA: 0x0006FF00 File Offset: 0x0006E100
		[DebuggerStepThrough]
		public Task<OperateResult> RenameKeyAsync(string key1, string key2)
		{
			RedisClientPool.<RenameKeyAsync>d__30 <RenameKeyAsync>d__ = new RedisClientPool.<RenameKeyAsync>d__30();
			<RenameKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<RenameKeyAsync>d__.<>4__this = this;
			<RenameKeyAsync>d__.key1 = key1;
			<RenameKeyAsync>d__.key2 = key2;
			<RenameKeyAsync>d__.<>1__state = -1;
			<RenameKeyAsync>d__.<>t__builder.Start<RedisClientPool.<RenameKeyAsync>d__30>(ref <RenameKeyAsync>d__);
			return <RenameKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadKeyType(System.String)" />
		// Token: 0x060015A8 RID: 5544 RVA: 0x0006FF54 File Offset: 0x0006E154
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadKeyTypeAsync(string key)
		{
			RedisClientPool.<ReadKeyTypeAsync>d__31 <ReadKeyTypeAsync>d__ = new RedisClientPool.<ReadKeyTypeAsync>d__31();
			<ReadKeyTypeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadKeyTypeAsync>d__.<>4__this = this;
			<ReadKeyTypeAsync>d__.key = key;
			<ReadKeyTypeAsync>d__.<>1__state = -1;
			<ReadKeyTypeAsync>d__.<>t__builder.Start<RedisClientPool.<ReadKeyTypeAsync>d__31>(ref <ReadKeyTypeAsync>d__);
			return <ReadKeyTypeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadKeyTTL(System.String)" />
		// Token: 0x060015A9 RID: 5545 RVA: 0x0006FFA0 File Offset: 0x0006E1A0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadKeyTTLAsync(string key)
		{
			RedisClientPool.<ReadKeyTTLAsync>d__32 <ReadKeyTTLAsync>d__ = new RedisClientPool.<ReadKeyTTLAsync>d__32();
			<ReadKeyTTLAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadKeyTTLAsync>d__.<>4__this = this;
			<ReadKeyTTLAsync>d__.key = key;
			<ReadKeyTTLAsync>d__.<>1__state = -1;
			<ReadKeyTTLAsync>d__.<>t__builder.Start<RedisClientPool.<ReadKeyTTLAsync>d__32>(ref <ReadKeyTTLAsync>d__);
			return <ReadKeyTTLAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.AppendKey(System.String,System.String)" />
		// Token: 0x060015AA RID: 5546 RVA: 0x0006FFEC File Offset: 0x0006E1EC
		public OperateResult<int> AppendKey(string key, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.AppendKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DecrementKey(System.String)" />
		// Token: 0x060015AB RID: 5547 RVA: 0x00070020 File Offset: 0x0006E220
		public OperateResult<long> DecrementKey(string key)
		{
			return this.ConnectPoolExecute<long>((RedisClient m) => m.DecrementKey(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DecrementKey(System.String,System.Int64)" />
		// Token: 0x060015AC RID: 5548 RVA: 0x0007004C File Offset: 0x0006E24C
		public OperateResult<long> DecrementKey(string key, long value)
		{
			return this.ConnectPoolExecute<long>((RedisClient m) => m.DecrementKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKey(System.String)" />
		// Token: 0x060015AD RID: 5549 RVA: 0x00070080 File Offset: 0x0006E280
		public OperateResult<string> ReadKey(string key)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadKey(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyRange(System.String,System.Int32,System.Int32)" />
		// Token: 0x060015AE RID: 5550 RVA: 0x000700AC File Offset: 0x0006E2AC
		public OperateResult<string> ReadKeyRange(string key, int start, int end)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadKeyRange(key, start, end));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadAndWriteKey(System.String,System.String)" />
		// Token: 0x060015AF RID: 5551 RVA: 0x000700E8 File Offset: 0x0006E2E8
		public OperateResult<string> ReadAndWriteKey(string key, string value)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadAndWriteKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementKey(System.String)" />
		// Token: 0x060015B0 RID: 5552 RVA: 0x0007011C File Offset: 0x0006E31C
		public OperateResult<long> IncrementKey(string key)
		{
			return this.ConnectPoolExecute<long>((RedisClient m) => m.IncrementKey(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementKey(System.String,System.Int64)" />
		// Token: 0x060015B1 RID: 5553 RVA: 0x00070148 File Offset: 0x0006E348
		public OperateResult<long> IncrementKey(string key, long value)
		{
			return this.ConnectPoolExecute<long>((RedisClient m) => m.IncrementKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementKey(System.String,System.Single)" />
		// Token: 0x060015B2 RID: 5554 RVA: 0x0007017C File Offset: 0x0006E37C
		public OperateResult<string> IncrementKey(string key, float value)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.IncrementKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKey(System.String[])" />
		// Token: 0x060015B3 RID: 5555 RVA: 0x000701B0 File Offset: 0x0006E3B0
		public OperateResult<string[]> ReadKey(string[] keys)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ReadKey(keys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKey(System.String[],System.String[])" />
		// Token: 0x060015B4 RID: 5556 RVA: 0x000701DC File Offset: 0x0006E3DC
		public OperateResult WriteKey(string[] keys, string[] values)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.WriteKey(keys, values));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKey(System.String,System.String)" />
		// Token: 0x060015B5 RID: 5557 RVA: 0x00070210 File Offset: 0x0006E410
		public OperateResult WriteKey(string key, string value)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.WriteKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteAndPublishKey(System.String,System.String)" />
		// Token: 0x060015B6 RID: 5558 RVA: 0x00070244 File Offset: 0x0006E444
		public OperateResult WriteAndPublishKey(string key, string value)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.WriteAndPublishKey(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteExpireKey(System.String,System.String,System.Int64)" />
		// Token: 0x060015B7 RID: 5559 RVA: 0x00070278 File Offset: 0x0006E478
		public OperateResult WriteExpireKey(string key, string value, long seconds)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.WriteExpireKey(key, value, seconds));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKeyIfNotExists(System.String,System.String)" />
		// Token: 0x060015B8 RID: 5560 RVA: 0x000702B4 File Offset: 0x0006E4B4
		public OperateResult<int> WriteKeyIfNotExists(string key, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.WriteKeyIfNotExists(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKeyRange(System.String,System.String,System.Int32)" />
		// Token: 0x060015B9 RID: 5561 RVA: 0x000702E8 File Offset: 0x0006E4E8
		public OperateResult<int> WriteKeyRange(string key, string value, int offset)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.WriteKeyRange(key, value, offset));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyLength(System.String)" />
		// Token: 0x060015BA RID: 5562 RVA: 0x00070324 File Offset: 0x0006E524
		public OperateResult<int> ReadKeyLength(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ReadKeyLength(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.AppendKey(System.String,System.String)" />
		// Token: 0x060015BB RID: 5563 RVA: 0x00070350 File Offset: 0x0006E550
		[DebuggerStepThrough]
		public Task<OperateResult<int>> AppendKeyAsync(string key, string value)
		{
			RedisClientPool.<AppendKeyAsync>d__50 <AppendKeyAsync>d__ = new RedisClientPool.<AppendKeyAsync>d__50();
			<AppendKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<AppendKeyAsync>d__.<>4__this = this;
			<AppendKeyAsync>d__.key = key;
			<AppendKeyAsync>d__.value = value;
			<AppendKeyAsync>d__.<>1__state = -1;
			<AppendKeyAsync>d__.<>t__builder.Start<RedisClientPool.<AppendKeyAsync>d__50>(ref <AppendKeyAsync>d__);
			return <AppendKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DecrementKey(System.String)" />
		// Token: 0x060015BC RID: 5564 RVA: 0x000703A4 File Offset: 0x0006E5A4
		[DebuggerStepThrough]
		public Task<OperateResult<long>> DecrementKeyAsync(string key)
		{
			RedisClientPool.<DecrementKeyAsync>d__51 <DecrementKeyAsync>d__ = new RedisClientPool.<DecrementKeyAsync>d__51();
			<DecrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<DecrementKeyAsync>d__.<>4__this = this;
			<DecrementKeyAsync>d__.key = key;
			<DecrementKeyAsync>d__.<>1__state = -1;
			<DecrementKeyAsync>d__.<>t__builder.Start<RedisClientPool.<DecrementKeyAsync>d__51>(ref <DecrementKeyAsync>d__);
			return <DecrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DecrementKey(System.String,System.Int64)" />
		// Token: 0x060015BD RID: 5565 RVA: 0x000703F0 File Offset: 0x0006E5F0
		[DebuggerStepThrough]
		public Task<OperateResult<long>> DecrementKeyAsync(string key, long value)
		{
			RedisClientPool.<DecrementKeyAsync>d__52 <DecrementKeyAsync>d__ = new RedisClientPool.<DecrementKeyAsync>d__52();
			<DecrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<DecrementKeyAsync>d__.<>4__this = this;
			<DecrementKeyAsync>d__.key = key;
			<DecrementKeyAsync>d__.value = value;
			<DecrementKeyAsync>d__.<>1__state = -1;
			<DecrementKeyAsync>d__.<>t__builder.Start<RedisClientPool.<DecrementKeyAsync>d__52>(ref <DecrementKeyAsync>d__);
			return <DecrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadKey(System.String)" />
		// Token: 0x060015BE RID: 5566 RVA: 0x00070444 File Offset: 0x0006E644
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadKeyAsync(string key)
		{
			RedisClientPool.<ReadKeyAsync>d__53 <ReadKeyAsync>d__ = new RedisClientPool.<ReadKeyAsync>d__53();
			<ReadKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadKeyAsync>d__.<>4__this = this;
			<ReadKeyAsync>d__.key = key;
			<ReadKeyAsync>d__.<>1__state = -1;
			<ReadKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ReadKeyAsync>d__53>(ref <ReadKeyAsync>d__);
			return <ReadKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadKeyRange(System.String,System.Int32,System.Int32)" />
		// Token: 0x060015BF RID: 5567 RVA: 0x00070490 File Offset: 0x0006E690
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadKeyRangeAsync(string key, int start, int end)
		{
			RedisClientPool.<ReadKeyRangeAsync>d__54 <ReadKeyRangeAsync>d__ = new RedisClientPool.<ReadKeyRangeAsync>d__54();
			<ReadKeyRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadKeyRangeAsync>d__.<>4__this = this;
			<ReadKeyRangeAsync>d__.key = key;
			<ReadKeyRangeAsync>d__.start = start;
			<ReadKeyRangeAsync>d__.end = end;
			<ReadKeyRangeAsync>d__.<>1__state = -1;
			<ReadKeyRangeAsync>d__.<>t__builder.Start<RedisClientPool.<ReadKeyRangeAsync>d__54>(ref <ReadKeyRangeAsync>d__);
			return <ReadKeyRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadAndWriteKey(System.String,System.String)" />
		// Token: 0x060015C0 RID: 5568 RVA: 0x000704EC File Offset: 0x0006E6EC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadAndWriteKeyAsync(string key, string value)
		{
			RedisClientPool.<ReadAndWriteKeyAsync>d__55 <ReadAndWriteKeyAsync>d__ = new RedisClientPool.<ReadAndWriteKeyAsync>d__55();
			<ReadAndWriteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadAndWriteKeyAsync>d__.<>4__this = this;
			<ReadAndWriteKeyAsync>d__.key = key;
			<ReadAndWriteKeyAsync>d__.value = value;
			<ReadAndWriteKeyAsync>d__.<>1__state = -1;
			<ReadAndWriteKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ReadAndWriteKeyAsync>d__55>(ref <ReadAndWriteKeyAsync>d__);
			return <ReadAndWriteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.IncrementKey(System.String)" />
		// Token: 0x060015C1 RID: 5569 RVA: 0x00070540 File Offset: 0x0006E740
		[DebuggerStepThrough]
		public Task<OperateResult<long>> IncrementKeyAsync(string key)
		{
			RedisClientPool.<IncrementKeyAsync>d__56 <IncrementKeyAsync>d__ = new RedisClientPool.<IncrementKeyAsync>d__56();
			<IncrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<IncrementKeyAsync>d__.<>4__this = this;
			<IncrementKeyAsync>d__.key = key;
			<IncrementKeyAsync>d__.<>1__state = -1;
			<IncrementKeyAsync>d__.<>t__builder.Start<RedisClientPool.<IncrementKeyAsync>d__56>(ref <IncrementKeyAsync>d__);
			return <IncrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.IncrementKey(System.String,System.Int64)" />
		// Token: 0x060015C2 RID: 5570 RVA: 0x0007058C File Offset: 0x0006E78C
		[DebuggerStepThrough]
		public Task<OperateResult<long>> IncrementKeyAsync(string key, long value)
		{
			RedisClientPool.<IncrementKeyAsync>d__57 <IncrementKeyAsync>d__ = new RedisClientPool.<IncrementKeyAsync>d__57();
			<IncrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<IncrementKeyAsync>d__.<>4__this = this;
			<IncrementKeyAsync>d__.key = key;
			<IncrementKeyAsync>d__.value = value;
			<IncrementKeyAsync>d__.<>1__state = -1;
			<IncrementKeyAsync>d__.<>t__builder.Start<RedisClientPool.<IncrementKeyAsync>d__57>(ref <IncrementKeyAsync>d__);
			return <IncrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.IncrementKey(System.String,System.Single)" />
		// Token: 0x060015C3 RID: 5571 RVA: 0x000705E0 File Offset: 0x0006E7E0
		[DebuggerStepThrough]
		public Task<OperateResult<string>> IncrementKeyAsync(string key, float value)
		{
			RedisClientPool.<IncrementKeyAsync>d__58 <IncrementKeyAsync>d__ = new RedisClientPool.<IncrementKeyAsync>d__58();
			<IncrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<IncrementKeyAsync>d__.<>4__this = this;
			<IncrementKeyAsync>d__.key = key;
			<IncrementKeyAsync>d__.value = value;
			<IncrementKeyAsync>d__.<>1__state = -1;
			<IncrementKeyAsync>d__.<>t__builder.Start<RedisClientPool.<IncrementKeyAsync>d__58>(ref <IncrementKeyAsync>d__);
			return <IncrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadKey(System.String[])" />
		// Token: 0x060015C4 RID: 5572 RVA: 0x00070634 File Offset: 0x0006E834
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadKeyAsync(string[] keys)
		{
			RedisClientPool.<ReadKeyAsync>d__59 <ReadKeyAsync>d__ = new RedisClientPool.<ReadKeyAsync>d__59();
			<ReadKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadKeyAsync>d__.<>4__this = this;
			<ReadKeyAsync>d__.keys = keys;
			<ReadKeyAsync>d__.<>1__state = -1;
			<ReadKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ReadKeyAsync>d__59>(ref <ReadKeyAsync>d__);
			return <ReadKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteKey(System.String[],System.String[])" />
		// Token: 0x060015C5 RID: 5573 RVA: 0x00070680 File Offset: 0x0006E880
		[DebuggerStepThrough]
		public Task<OperateResult> WriteKeyAsync(string[] keys, string[] values)
		{
			RedisClientPool.<WriteKeyAsync>d__60 <WriteKeyAsync>d__ = new RedisClientPool.<WriteKeyAsync>d__60();
			<WriteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteKeyAsync>d__.<>4__this = this;
			<WriteKeyAsync>d__.keys = keys;
			<WriteKeyAsync>d__.values = values;
			<WriteKeyAsync>d__.<>1__state = -1;
			<WriteKeyAsync>d__.<>t__builder.Start<RedisClientPool.<WriteKeyAsync>d__60>(ref <WriteKeyAsync>d__);
			return <WriteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteKey(System.String,System.String)" />
		// Token: 0x060015C6 RID: 5574 RVA: 0x000706D4 File Offset: 0x0006E8D4
		[DebuggerStepThrough]
		public Task<OperateResult> WriteKeyAsync(string key, string value)
		{
			RedisClientPool.<WriteKeyAsync>d__61 <WriteKeyAsync>d__ = new RedisClientPool.<WriteKeyAsync>d__61();
			<WriteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteKeyAsync>d__.<>4__this = this;
			<WriteKeyAsync>d__.key = key;
			<WriteKeyAsync>d__.value = value;
			<WriteKeyAsync>d__.<>1__state = -1;
			<WriteKeyAsync>d__.<>t__builder.Start<RedisClientPool.<WriteKeyAsync>d__61>(ref <WriteKeyAsync>d__);
			return <WriteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteAndPublishKey(System.String,System.String)" />
		// Token: 0x060015C7 RID: 5575 RVA: 0x00070728 File Offset: 0x0006E928
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAndPublishKeyAsync(string key, string value)
		{
			RedisClientPool.<WriteAndPublishKeyAsync>d__62 <WriteAndPublishKeyAsync>d__ = new RedisClientPool.<WriteAndPublishKeyAsync>d__62();
			<WriteAndPublishKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAndPublishKeyAsync>d__.<>4__this = this;
			<WriteAndPublishKeyAsync>d__.key = key;
			<WriteAndPublishKeyAsync>d__.value = value;
			<WriteAndPublishKeyAsync>d__.<>1__state = -1;
			<WriteAndPublishKeyAsync>d__.<>t__builder.Start<RedisClientPool.<WriteAndPublishKeyAsync>d__62>(ref <WriteAndPublishKeyAsync>d__);
			return <WriteAndPublishKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteExpireKey(System.String,System.String,System.Int64)" />
		// Token: 0x060015C8 RID: 5576 RVA: 0x0007077C File Offset: 0x0006E97C
		[DebuggerStepThrough]
		public Task<OperateResult> WriteExpireKeyAsync(string key, string value, long seconds)
		{
			RedisClientPool.<WriteExpireKeyAsync>d__63 <WriteExpireKeyAsync>d__ = new RedisClientPool.<WriteExpireKeyAsync>d__63();
			<WriteExpireKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteExpireKeyAsync>d__.<>4__this = this;
			<WriteExpireKeyAsync>d__.key = key;
			<WriteExpireKeyAsync>d__.value = value;
			<WriteExpireKeyAsync>d__.seconds = seconds;
			<WriteExpireKeyAsync>d__.<>1__state = -1;
			<WriteExpireKeyAsync>d__.<>t__builder.Start<RedisClientPool.<WriteExpireKeyAsync>d__63>(ref <WriteExpireKeyAsync>d__);
			return <WriteExpireKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteKeyIfNotExists(System.String,System.String)" />
		// Token: 0x060015C9 RID: 5577 RVA: 0x000707D8 File Offset: 0x0006E9D8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteKeyIfNotExistsAsync(string key, string value)
		{
			RedisClientPool.<WriteKeyIfNotExistsAsync>d__64 <WriteKeyIfNotExistsAsync>d__ = new RedisClientPool.<WriteKeyIfNotExistsAsync>d__64();
			<WriteKeyIfNotExistsAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteKeyIfNotExistsAsync>d__.<>4__this = this;
			<WriteKeyIfNotExistsAsync>d__.key = key;
			<WriteKeyIfNotExistsAsync>d__.value = value;
			<WriteKeyIfNotExistsAsync>d__.<>1__state = -1;
			<WriteKeyIfNotExistsAsync>d__.<>t__builder.Start<RedisClientPool.<WriteKeyIfNotExistsAsync>d__64>(ref <WriteKeyIfNotExistsAsync>d__);
			return <WriteKeyIfNotExistsAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteKeyRange(System.String,System.String,System.Int32)" />
		// Token: 0x060015CA RID: 5578 RVA: 0x0007082C File Offset: 0x0006EA2C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteKeyRangeAsync(string key, string value, int offset)
		{
			RedisClientPool.<WriteKeyRangeAsync>d__65 <WriteKeyRangeAsync>d__ = new RedisClientPool.<WriteKeyRangeAsync>d__65();
			<WriteKeyRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteKeyRangeAsync>d__.<>4__this = this;
			<WriteKeyRangeAsync>d__.key = key;
			<WriteKeyRangeAsync>d__.value = value;
			<WriteKeyRangeAsync>d__.offset = offset;
			<WriteKeyRangeAsync>d__.<>1__state = -1;
			<WriteKeyRangeAsync>d__.<>t__builder.Start<RedisClientPool.<WriteKeyRangeAsync>d__65>(ref <WriteKeyRangeAsync>d__);
			return <WriteKeyRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadKeyLength(System.String)" />
		// Token: 0x060015CB RID: 5579 RVA: 0x00070888 File Offset: 0x0006EA88
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadKeyLengthAsync(string key)
		{
			RedisClientPool.<ReadKeyLengthAsync>d__66 <ReadKeyLengthAsync>d__ = new RedisClientPool.<ReadKeyLengthAsync>d__66();
			<ReadKeyLengthAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadKeyLengthAsync>d__.<>4__this = this;
			<ReadKeyLengthAsync>d__.key = key;
			<ReadKeyLengthAsync>d__.<>1__state = -1;
			<ReadKeyLengthAsync>d__.<>t__builder.Start<RedisClientPool.<ReadKeyLengthAsync>d__66>(ref <ReadKeyLengthAsync>d__);
			return <ReadKeyLengthAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListInsertBefore(System.String,System.String,System.String)" />
		// Token: 0x060015CC RID: 5580 RVA: 0x000708D4 File Offset: 0x0006EAD4
		public OperateResult<int> ListInsertBefore(string key, string value, string pivot)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListInsertBefore(key, value, pivot));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListInsertAfter(System.String,System.String,System.String)" />
		// Token: 0x060015CD RID: 5581 RVA: 0x00070910 File Offset: 0x0006EB10
		public OperateResult<int> ListInsertAfter(string key, string value, string pivot)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListInsertAfter(key, value, pivot));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.GetListLength(System.String)" />
		// Token: 0x060015CE RID: 5582 RVA: 0x0007094C File Offset: 0x0006EB4C
		public OperateResult<int> GetListLength(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.GetListLength(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadListByIndex(System.String,System.Int64)" />
		// Token: 0x060015CF RID: 5583 RVA: 0x00070978 File Offset: 0x0006EB78
		public OperateResult<string> ReadListByIndex(string key, long index)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadListByIndex(key, index));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPop(System.String)" />
		// Token: 0x060015D0 RID: 5584 RVA: 0x000709AC File Offset: 0x0006EBAC
		public OperateResult<string> ListLeftPop(string key)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ListLeftPop(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPush(System.String,System.String)" />
		// Token: 0x060015D1 RID: 5585 RVA: 0x000709D8 File Offset: 0x0006EBD8
		public OperateResult<int> ListLeftPush(string key, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListLeftPush(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPush(System.String,System.String[])" />
		// Token: 0x060015D2 RID: 5586 RVA: 0x00070A0C File Offset: 0x0006EC0C
		public OperateResult<int> ListLeftPush(string key, string[] values)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListLeftPush(key, values));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPushX(System.String,System.String)" />
		// Token: 0x060015D3 RID: 5587 RVA: 0x00070A40 File Offset: 0x0006EC40
		public OperateResult<int> ListLeftPushX(string key, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListLeftPushX(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRange(System.String,System.Int64,System.Int64)" />
		// Token: 0x060015D4 RID: 5588 RVA: 0x00070A74 File Offset: 0x0006EC74
		public OperateResult<string[]> ListRange(string key, long start, long stop)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ListRange(key, start, stop));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRemoveElementMatch(System.String,System.Int64,System.String)" />
		// Token: 0x060015D5 RID: 5589 RVA: 0x00070AB0 File Offset: 0x0006ECB0
		public OperateResult<int> ListRemoveElementMatch(string key, long count, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListRemoveElementMatch(key, count, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListSet(System.String,System.Int64,System.String)" />
		// Token: 0x060015D6 RID: 5590 RVA: 0x00070AEC File Offset: 0x0006ECEC
		public OperateResult ListSet(string key, long index, string value)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.ListSet(key, index, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListTrim(System.String,System.Int64,System.Int64)" />
		// Token: 0x060015D7 RID: 5591 RVA: 0x00070B28 File Offset: 0x0006ED28
		public OperateResult ListTrim(string key, long start, long end)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.ListTrim(key, start, end));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPop(System.String)" />
		// Token: 0x060015D8 RID: 5592 RVA: 0x00070B64 File Offset: 0x0006ED64
		public OperateResult<string> ListRightPop(string key)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ListRightPop(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPopLeftPush(System.String,System.String)" />
		// Token: 0x060015D9 RID: 5593 RVA: 0x00070B90 File Offset: 0x0006ED90
		public OperateResult<string> ListRightPopLeftPush(string key1, string key2)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ListRightPopLeftPush(key1, key2));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPush(System.String,System.String)" />
		// Token: 0x060015DA RID: 5594 RVA: 0x00070BC4 File Offset: 0x0006EDC4
		public OperateResult<int> ListRightPush(string key, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListRightPush(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPush(System.String,System.String[])" />
		// Token: 0x060015DB RID: 5595 RVA: 0x00070BF8 File Offset: 0x0006EDF8
		public OperateResult<int> ListRightPush(string key, string[] values)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListRightPush(key, values));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPushX(System.String,System.String)" />
		// Token: 0x060015DC RID: 5596 RVA: 0x00070C2C File Offset: 0x0006EE2C
		public OperateResult<int> ListRightPushX(string key, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ListRightPushX(key, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListInsertBefore(System.String,System.String,System.String)" />
		// Token: 0x060015DD RID: 5597 RVA: 0x00070C60 File Offset: 0x0006EE60
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListInsertBeforeAsync(string key, string value, string pivot)
		{
			RedisClientPool.<ListInsertBeforeAsync>d__84 <ListInsertBeforeAsync>d__ = new RedisClientPool.<ListInsertBeforeAsync>d__84();
			<ListInsertBeforeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListInsertBeforeAsync>d__.<>4__this = this;
			<ListInsertBeforeAsync>d__.key = key;
			<ListInsertBeforeAsync>d__.value = value;
			<ListInsertBeforeAsync>d__.pivot = pivot;
			<ListInsertBeforeAsync>d__.<>1__state = -1;
			<ListInsertBeforeAsync>d__.<>t__builder.Start<RedisClientPool.<ListInsertBeforeAsync>d__84>(ref <ListInsertBeforeAsync>d__);
			return <ListInsertBeforeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListInsertAfter(System.String,System.String,System.String)" />
		// Token: 0x060015DE RID: 5598 RVA: 0x00070CBC File Offset: 0x0006EEBC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListInsertAfterAsync(string key, string value, string pivot)
		{
			RedisClientPool.<ListInsertAfterAsync>d__85 <ListInsertAfterAsync>d__ = new RedisClientPool.<ListInsertAfterAsync>d__85();
			<ListInsertAfterAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListInsertAfterAsync>d__.<>4__this = this;
			<ListInsertAfterAsync>d__.key = key;
			<ListInsertAfterAsync>d__.value = value;
			<ListInsertAfterAsync>d__.pivot = pivot;
			<ListInsertAfterAsync>d__.<>1__state = -1;
			<ListInsertAfterAsync>d__.<>t__builder.Start<RedisClientPool.<ListInsertAfterAsync>d__85>(ref <ListInsertAfterAsync>d__);
			return <ListInsertAfterAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.GetListLength(System.String)" />
		// Token: 0x060015DF RID: 5599 RVA: 0x00070D18 File Offset: 0x0006EF18
		[DebuggerStepThrough]
		public Task<OperateResult<int>> GetListLengthAsync(string key)
		{
			RedisClientPool.<GetListLengthAsync>d__86 <GetListLengthAsync>d__ = new RedisClientPool.<GetListLengthAsync>d__86();
			<GetListLengthAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<GetListLengthAsync>d__.<>4__this = this;
			<GetListLengthAsync>d__.key = key;
			<GetListLengthAsync>d__.<>1__state = -1;
			<GetListLengthAsync>d__.<>t__builder.Start<RedisClientPool.<GetListLengthAsync>d__86>(ref <GetListLengthAsync>d__);
			return <GetListLengthAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadListByIndex(System.String,System.Int64)" />
		// Token: 0x060015E0 RID: 5600 RVA: 0x00070D64 File Offset: 0x0006EF64
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadListByIndexAsync(string key, long index)
		{
			RedisClientPool.<ReadListByIndexAsync>d__87 <ReadListByIndexAsync>d__ = new RedisClientPool.<ReadListByIndexAsync>d__87();
			<ReadListByIndexAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadListByIndexAsync>d__.<>4__this = this;
			<ReadListByIndexAsync>d__.key = key;
			<ReadListByIndexAsync>d__.index = index;
			<ReadListByIndexAsync>d__.<>1__state = -1;
			<ReadListByIndexAsync>d__.<>t__builder.Start<RedisClientPool.<ReadListByIndexAsync>d__87>(ref <ReadListByIndexAsync>d__);
			return <ReadListByIndexAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListLeftPop(System.String)" />
		// Token: 0x060015E1 RID: 5601 RVA: 0x00070DB8 File Offset: 0x0006EFB8
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ListLeftPopAsync(string key)
		{
			RedisClientPool.<ListLeftPopAsync>d__88 <ListLeftPopAsync>d__ = new RedisClientPool.<ListLeftPopAsync>d__88();
			<ListLeftPopAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ListLeftPopAsync>d__.<>4__this = this;
			<ListLeftPopAsync>d__.key = key;
			<ListLeftPopAsync>d__.<>1__state = -1;
			<ListLeftPopAsync>d__.<>t__builder.Start<RedisClientPool.<ListLeftPopAsync>d__88>(ref <ListLeftPopAsync>d__);
			return <ListLeftPopAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListLeftPush(System.String,System.String)" />
		// Token: 0x060015E2 RID: 5602 RVA: 0x00070E04 File Offset: 0x0006F004
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListLeftPushAsync(string key, string value)
		{
			RedisClientPool.<ListLeftPushAsync>d__89 <ListLeftPushAsync>d__ = new RedisClientPool.<ListLeftPushAsync>d__89();
			<ListLeftPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListLeftPushAsync>d__.<>4__this = this;
			<ListLeftPushAsync>d__.key = key;
			<ListLeftPushAsync>d__.value = value;
			<ListLeftPushAsync>d__.<>1__state = -1;
			<ListLeftPushAsync>d__.<>t__builder.Start<RedisClientPool.<ListLeftPushAsync>d__89>(ref <ListLeftPushAsync>d__);
			return <ListLeftPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListLeftPush(System.String,System.String[])" />
		// Token: 0x060015E3 RID: 5603 RVA: 0x00070E58 File Offset: 0x0006F058
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListLeftPushAsync(string key, string[] values)
		{
			RedisClientPool.<ListLeftPushAsync>d__90 <ListLeftPushAsync>d__ = new RedisClientPool.<ListLeftPushAsync>d__90();
			<ListLeftPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListLeftPushAsync>d__.<>4__this = this;
			<ListLeftPushAsync>d__.key = key;
			<ListLeftPushAsync>d__.values = values;
			<ListLeftPushAsync>d__.<>1__state = -1;
			<ListLeftPushAsync>d__.<>t__builder.Start<RedisClientPool.<ListLeftPushAsync>d__90>(ref <ListLeftPushAsync>d__);
			return <ListLeftPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListLeftPushX(System.String,System.String)" />
		// Token: 0x060015E4 RID: 5604 RVA: 0x00070EAC File Offset: 0x0006F0AC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListLeftPushXAsync(string key, string value)
		{
			RedisClientPool.<ListLeftPushXAsync>d__91 <ListLeftPushXAsync>d__ = new RedisClientPool.<ListLeftPushXAsync>d__91();
			<ListLeftPushXAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListLeftPushXAsync>d__.<>4__this = this;
			<ListLeftPushXAsync>d__.key = key;
			<ListLeftPushXAsync>d__.value = value;
			<ListLeftPushXAsync>d__.<>1__state = -1;
			<ListLeftPushXAsync>d__.<>t__builder.Start<RedisClientPool.<ListLeftPushXAsync>d__91>(ref <ListLeftPushXAsync>d__);
			return <ListLeftPushXAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRange(System.String,System.Int64,System.Int64)" />
		// Token: 0x060015E5 RID: 5605 RVA: 0x00070F00 File Offset: 0x0006F100
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ListRangeAsync(string key, long start, long stop)
		{
			RedisClientPool.<ListRangeAsync>d__92 <ListRangeAsync>d__ = new RedisClientPool.<ListRangeAsync>d__92();
			<ListRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ListRangeAsync>d__.<>4__this = this;
			<ListRangeAsync>d__.key = key;
			<ListRangeAsync>d__.start = start;
			<ListRangeAsync>d__.stop = stop;
			<ListRangeAsync>d__.<>1__state = -1;
			<ListRangeAsync>d__.<>t__builder.Start<RedisClientPool.<ListRangeAsync>d__92>(ref <ListRangeAsync>d__);
			return <ListRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRemoveElementMatch(System.String,System.Int64,System.String)" />
		// Token: 0x060015E6 RID: 5606 RVA: 0x00070F5C File Offset: 0x0006F15C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRemoveElementMatchAsync(string key, long count, string value)
		{
			RedisClientPool.<ListRemoveElementMatchAsync>d__93 <ListRemoveElementMatchAsync>d__ = new RedisClientPool.<ListRemoveElementMatchAsync>d__93();
			<ListRemoveElementMatchAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRemoveElementMatchAsync>d__.<>4__this = this;
			<ListRemoveElementMatchAsync>d__.key = key;
			<ListRemoveElementMatchAsync>d__.count = count;
			<ListRemoveElementMatchAsync>d__.value = value;
			<ListRemoveElementMatchAsync>d__.<>1__state = -1;
			<ListRemoveElementMatchAsync>d__.<>t__builder.Start<RedisClientPool.<ListRemoveElementMatchAsync>d__93>(ref <ListRemoveElementMatchAsync>d__);
			return <ListRemoveElementMatchAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListSet(System.String,System.Int64,System.String)" />
		// Token: 0x060015E7 RID: 5607 RVA: 0x00070FB8 File Offset: 0x0006F1B8
		[DebuggerStepThrough]
		public Task<OperateResult> ListSetAsync(string key, long index, string value)
		{
			RedisClientPool.<ListSetAsync>d__94 <ListSetAsync>d__ = new RedisClientPool.<ListSetAsync>d__94();
			<ListSetAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ListSetAsync>d__.<>4__this = this;
			<ListSetAsync>d__.key = key;
			<ListSetAsync>d__.index = index;
			<ListSetAsync>d__.value = value;
			<ListSetAsync>d__.<>1__state = -1;
			<ListSetAsync>d__.<>t__builder.Start<RedisClientPool.<ListSetAsync>d__94>(ref <ListSetAsync>d__);
			return <ListSetAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListTrim(System.String,System.Int64,System.Int64)" />
		// Token: 0x060015E8 RID: 5608 RVA: 0x00071014 File Offset: 0x0006F214
		[DebuggerStepThrough]
		public Task<OperateResult> ListTrimAsync(string key, long start, long end)
		{
			RedisClientPool.<ListTrimAsync>d__95 <ListTrimAsync>d__ = new RedisClientPool.<ListTrimAsync>d__95();
			<ListTrimAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ListTrimAsync>d__.<>4__this = this;
			<ListTrimAsync>d__.key = key;
			<ListTrimAsync>d__.start = start;
			<ListTrimAsync>d__.end = end;
			<ListTrimAsync>d__.<>1__state = -1;
			<ListTrimAsync>d__.<>t__builder.Start<RedisClientPool.<ListTrimAsync>d__95>(ref <ListTrimAsync>d__);
			return <ListTrimAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRightPop(System.String)" />
		// Token: 0x060015E9 RID: 5609 RVA: 0x00071070 File Offset: 0x0006F270
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ListRightPopAsync(string key)
		{
			RedisClientPool.<ListRightPopAsync>d__96 <ListRightPopAsync>d__ = new RedisClientPool.<ListRightPopAsync>d__96();
			<ListRightPopAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ListRightPopAsync>d__.<>4__this = this;
			<ListRightPopAsync>d__.key = key;
			<ListRightPopAsync>d__.<>1__state = -1;
			<ListRightPopAsync>d__.<>t__builder.Start<RedisClientPool.<ListRightPopAsync>d__96>(ref <ListRightPopAsync>d__);
			return <ListRightPopAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRightPopLeftPush(System.String,System.String)" />
		// Token: 0x060015EA RID: 5610 RVA: 0x000710BC File Offset: 0x0006F2BC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ListRightPopLeftPushAsync(string key1, string key2)
		{
			RedisClientPool.<ListRightPopLeftPushAsync>d__97 <ListRightPopLeftPushAsync>d__ = new RedisClientPool.<ListRightPopLeftPushAsync>d__97();
			<ListRightPopLeftPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ListRightPopLeftPushAsync>d__.<>4__this = this;
			<ListRightPopLeftPushAsync>d__.key1 = key1;
			<ListRightPopLeftPushAsync>d__.key2 = key2;
			<ListRightPopLeftPushAsync>d__.<>1__state = -1;
			<ListRightPopLeftPushAsync>d__.<>t__builder.Start<RedisClientPool.<ListRightPopLeftPushAsync>d__97>(ref <ListRightPopLeftPushAsync>d__);
			return <ListRightPopLeftPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRightPush(System.String,System.String)" />
		// Token: 0x060015EB RID: 5611 RVA: 0x00071110 File Offset: 0x0006F310
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRightPushAsync(string key, string value)
		{
			RedisClientPool.<ListRightPushAsync>d__98 <ListRightPushAsync>d__ = new RedisClientPool.<ListRightPushAsync>d__98();
			<ListRightPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRightPushAsync>d__.<>4__this = this;
			<ListRightPushAsync>d__.key = key;
			<ListRightPushAsync>d__.value = value;
			<ListRightPushAsync>d__.<>1__state = -1;
			<ListRightPushAsync>d__.<>t__builder.Start<RedisClientPool.<ListRightPushAsync>d__98>(ref <ListRightPushAsync>d__);
			return <ListRightPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRightPush(System.String,System.String[])" />
		// Token: 0x060015EC RID: 5612 RVA: 0x00071164 File Offset: 0x0006F364
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRightPushAsync(string key, string[] values)
		{
			RedisClientPool.<ListRightPushAsync>d__99 <ListRightPushAsync>d__ = new RedisClientPool.<ListRightPushAsync>d__99();
			<ListRightPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRightPushAsync>d__.<>4__this = this;
			<ListRightPushAsync>d__.key = key;
			<ListRightPushAsync>d__.values = values;
			<ListRightPushAsync>d__.<>1__state = -1;
			<ListRightPushAsync>d__.<>t__builder.Start<RedisClientPool.<ListRightPushAsync>d__99>(ref <ListRightPushAsync>d__);
			return <ListRightPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ListRightPushX(System.String,System.String)" />
		// Token: 0x060015ED RID: 5613 RVA: 0x000711B8 File Offset: 0x0006F3B8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRightPushXAsync(string key, string value)
		{
			RedisClientPool.<ListRightPushXAsync>d__100 <ListRightPushXAsync>d__ = new RedisClientPool.<ListRightPushXAsync>d__100();
			<ListRightPushXAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRightPushXAsync>d__.<>4__this = this;
			<ListRightPushXAsync>d__.key = key;
			<ListRightPushXAsync>d__.value = value;
			<ListRightPushXAsync>d__.<>1__state = -1;
			<ListRightPushXAsync>d__.<>t__builder.Start<RedisClientPool.<ListRightPushXAsync>d__100>(ref <ListRightPushXAsync>d__);
			return <ListRightPushXAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteHashKey(System.String,System.String)" />
		// Token: 0x060015EE RID: 5614 RVA: 0x0007120C File Offset: 0x0006F40C
		public OperateResult<int> DeleteHashKey(string key, string field)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.DeleteHashKey(key, field));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteHashKey(System.String,System.String[])" />
		// Token: 0x060015EF RID: 5615 RVA: 0x00071240 File Offset: 0x0006F440
		public OperateResult<int> DeleteHashKey(string key, string[] fields)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.DeleteHashKey(key, fields));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ExistsHashKey(System.String,System.String)" />
		// Token: 0x060015F0 RID: 5616 RVA: 0x00071274 File Offset: 0x0006F474
		public OperateResult<int> ExistsHashKey(string key, string field)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ExistsHashKey(key, field));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKey(System.String,System.String)" />
		// Token: 0x060015F1 RID: 5617 RVA: 0x000712A8 File Offset: 0x0006F4A8
		public OperateResult<string> ReadHashKey(string key, string field)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ReadHashKey(key, field));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKeyAll(System.String)" />
		// Token: 0x060015F2 RID: 5618 RVA: 0x000712DC File Offset: 0x0006F4DC
		public OperateResult<string[]> ReadHashKeyAll(string key)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ReadHashKeyAll(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementHashKey(System.String,System.String,System.Int64)" />
		// Token: 0x060015F3 RID: 5619 RVA: 0x00071308 File Offset: 0x0006F508
		public OperateResult<long> IncrementHashKey(string key, string field, long value)
		{
			return this.ConnectPoolExecute<long>((RedisClient m) => m.IncrementHashKey(key, field, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementHashKey(System.String,System.String,System.Single)" />
		// Token: 0x060015F4 RID: 5620 RVA: 0x00071344 File Offset: 0x0006F544
		public OperateResult<string> IncrementHashKey(string key, string field, float value)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.IncrementHashKey(key, field, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKeys(System.String)" />
		// Token: 0x060015F5 RID: 5621 RVA: 0x00071380 File Offset: 0x0006F580
		public OperateResult<string[]> ReadHashKeys(string key)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ReadHashKeys(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKeyLength(System.String)" />
		// Token: 0x060015F6 RID: 5622 RVA: 0x000713AC File Offset: 0x0006F5AC
		public OperateResult<int> ReadHashKeyLength(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ReadHashKeyLength(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKey(System.String,System.String[])" />
		// Token: 0x060015F7 RID: 5623 RVA: 0x000713D8 File Offset: 0x0006F5D8
		public OperateResult<string[]> ReadHashKey(string key, string[] fields)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ReadHashKey(key, fields));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteHashKey(System.String,System.String,System.String)" />
		// Token: 0x060015F8 RID: 5624 RVA: 0x0007140C File Offset: 0x0006F60C
		public OperateResult<int> WriteHashKey(string key, string field, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.WriteHashKey(key, field, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteHashKey(System.String,System.String[],System.String[])" />
		// Token: 0x060015F9 RID: 5625 RVA: 0x00071448 File Offset: 0x0006F648
		public OperateResult WriteHashKey(string key, string[] fields, string[] values)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.WriteHashKey(key, fields, values));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteHashKeyNx(System.String,System.String,System.String)" />
		// Token: 0x060015FA RID: 5626 RVA: 0x00071484 File Offset: 0x0006F684
		public OperateResult<int> WriteHashKeyNx(string key, string field, string value)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.WriteHashKeyNx(key, field, value));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashValues(System.String)" />
		// Token: 0x060015FB RID: 5627 RVA: 0x000714C0 File Offset: 0x0006F6C0
		public OperateResult<string[]> ReadHashValues(string key)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ReadHashValues(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DeleteHashKey(System.String,System.String)" />
		// Token: 0x060015FC RID: 5628 RVA: 0x000714EC File Offset: 0x0006F6EC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteHashKeyAsync(string key, string field)
		{
			RedisClientPool.<DeleteHashKeyAsync>d__115 <DeleteHashKeyAsync>d__ = new RedisClientPool.<DeleteHashKeyAsync>d__115();
			<DeleteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteHashKeyAsync>d__.<>4__this = this;
			<DeleteHashKeyAsync>d__.key = key;
			<DeleteHashKeyAsync>d__.field = field;
			<DeleteHashKeyAsync>d__.<>1__state = -1;
			<DeleteHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<DeleteHashKeyAsync>d__115>(ref <DeleteHashKeyAsync>d__);
			return <DeleteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DeleteHashKey(System.String,System.String[])" />
		// Token: 0x060015FD RID: 5629 RVA: 0x00071540 File Offset: 0x0006F740
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteHashKeyAsync(string key, string[] fields)
		{
			RedisClientPool.<DeleteHashKeyAsync>d__116 <DeleteHashKeyAsync>d__ = new RedisClientPool.<DeleteHashKeyAsync>d__116();
			<DeleteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteHashKeyAsync>d__.<>4__this = this;
			<DeleteHashKeyAsync>d__.key = key;
			<DeleteHashKeyAsync>d__.fields = fields;
			<DeleteHashKeyAsync>d__.<>1__state = -1;
			<DeleteHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<DeleteHashKeyAsync>d__116>(ref <DeleteHashKeyAsync>d__);
			return <DeleteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ExistsHashKey(System.String,System.String)" />
		// Token: 0x060015FE RID: 5630 RVA: 0x00071594 File Offset: 0x0006F794
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ExistsHashKeyAsync(string key, string field)
		{
			RedisClientPool.<ExistsHashKeyAsync>d__117 <ExistsHashKeyAsync>d__ = new RedisClientPool.<ExistsHashKeyAsync>d__117();
			<ExistsHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ExistsHashKeyAsync>d__.<>4__this = this;
			<ExistsHashKeyAsync>d__.key = key;
			<ExistsHashKeyAsync>d__.field = field;
			<ExistsHashKeyAsync>d__.<>1__state = -1;
			<ExistsHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ExistsHashKeyAsync>d__117>(ref <ExistsHashKeyAsync>d__);
			return <ExistsHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadHashKey(System.String,System.String)" />
		// Token: 0x060015FF RID: 5631 RVA: 0x000715E8 File Offset: 0x0006F7E8
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadHashKeyAsync(string key, string field)
		{
			RedisClientPool.<ReadHashKeyAsync>d__118 <ReadHashKeyAsync>d__ = new RedisClientPool.<ReadHashKeyAsync>d__118();
			<ReadHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadHashKeyAsync>d__.<>4__this = this;
			<ReadHashKeyAsync>d__.key = key;
			<ReadHashKeyAsync>d__.field = field;
			<ReadHashKeyAsync>d__.<>1__state = -1;
			<ReadHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ReadHashKeyAsync>d__118>(ref <ReadHashKeyAsync>d__);
			return <ReadHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadHashKeyAll(System.String)" />
		// Token: 0x06001600 RID: 5632 RVA: 0x0007163C File Offset: 0x0006F83C
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashKeyAllAsync(string key)
		{
			RedisClientPool.<ReadHashKeyAllAsync>d__119 <ReadHashKeyAllAsync>d__ = new RedisClientPool.<ReadHashKeyAllAsync>d__119();
			<ReadHashKeyAllAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashKeyAllAsync>d__.<>4__this = this;
			<ReadHashKeyAllAsync>d__.key = key;
			<ReadHashKeyAllAsync>d__.<>1__state = -1;
			<ReadHashKeyAllAsync>d__.<>t__builder.Start<RedisClientPool.<ReadHashKeyAllAsync>d__119>(ref <ReadHashKeyAllAsync>d__);
			return <ReadHashKeyAllAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.IncrementHashKey(System.String,System.String,System.Int64)" />
		// Token: 0x06001601 RID: 5633 RVA: 0x00071688 File Offset: 0x0006F888
		[DebuggerStepThrough]
		public Task<OperateResult<long>> IncrementHashKeyAsync(string key, string field, long value)
		{
			RedisClientPool.<IncrementHashKeyAsync>d__120 <IncrementHashKeyAsync>d__ = new RedisClientPool.<IncrementHashKeyAsync>d__120();
			<IncrementHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<IncrementHashKeyAsync>d__.<>4__this = this;
			<IncrementHashKeyAsync>d__.key = key;
			<IncrementHashKeyAsync>d__.field = field;
			<IncrementHashKeyAsync>d__.value = value;
			<IncrementHashKeyAsync>d__.<>1__state = -1;
			<IncrementHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<IncrementHashKeyAsync>d__120>(ref <IncrementHashKeyAsync>d__);
			return <IncrementHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.IncrementHashKey(System.String,System.String,System.Single)" />
		// Token: 0x06001602 RID: 5634 RVA: 0x000716E4 File Offset: 0x0006F8E4
		[DebuggerStepThrough]
		public Task<OperateResult<string>> IncrementHashKeyAsync(string key, string field, float value)
		{
			RedisClientPool.<IncrementHashKeyAsync>d__121 <IncrementHashKeyAsync>d__ = new RedisClientPool.<IncrementHashKeyAsync>d__121();
			<IncrementHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<IncrementHashKeyAsync>d__.<>4__this = this;
			<IncrementHashKeyAsync>d__.key = key;
			<IncrementHashKeyAsync>d__.field = field;
			<IncrementHashKeyAsync>d__.value = value;
			<IncrementHashKeyAsync>d__.<>1__state = -1;
			<IncrementHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<IncrementHashKeyAsync>d__121>(ref <IncrementHashKeyAsync>d__);
			return <IncrementHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadHashKeys(System.String)" />
		// Token: 0x06001603 RID: 5635 RVA: 0x00071740 File Offset: 0x0006F940
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashKeysAsync(string key)
		{
			RedisClientPool.<ReadHashKeysAsync>d__122 <ReadHashKeysAsync>d__ = new RedisClientPool.<ReadHashKeysAsync>d__122();
			<ReadHashKeysAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashKeysAsync>d__.<>4__this = this;
			<ReadHashKeysAsync>d__.key = key;
			<ReadHashKeysAsync>d__.<>1__state = -1;
			<ReadHashKeysAsync>d__.<>t__builder.Start<RedisClientPool.<ReadHashKeysAsync>d__122>(ref <ReadHashKeysAsync>d__);
			return <ReadHashKeysAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadHashKeyLength(System.String)" />
		// Token: 0x06001604 RID: 5636 RVA: 0x0007178C File Offset: 0x0006F98C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadHashKeyLengthAsync(string key)
		{
			RedisClientPool.<ReadHashKeyLengthAsync>d__123 <ReadHashKeyLengthAsync>d__ = new RedisClientPool.<ReadHashKeyLengthAsync>d__123();
			<ReadHashKeyLengthAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadHashKeyLengthAsync>d__.<>4__this = this;
			<ReadHashKeyLengthAsync>d__.key = key;
			<ReadHashKeyLengthAsync>d__.<>1__state = -1;
			<ReadHashKeyLengthAsync>d__.<>t__builder.Start<RedisClientPool.<ReadHashKeyLengthAsync>d__123>(ref <ReadHashKeyLengthAsync>d__);
			return <ReadHashKeyLengthAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadHashKey(System.String,System.String[])" />
		// Token: 0x06001605 RID: 5637 RVA: 0x000717D8 File Offset: 0x0006F9D8
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashKeyAsync(string key, string[] fields)
		{
			RedisClientPool.<ReadHashKeyAsync>d__124 <ReadHashKeyAsync>d__ = new RedisClientPool.<ReadHashKeyAsync>d__124();
			<ReadHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashKeyAsync>d__.<>4__this = this;
			<ReadHashKeyAsync>d__.key = key;
			<ReadHashKeyAsync>d__.fields = fields;
			<ReadHashKeyAsync>d__.<>1__state = -1;
			<ReadHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<ReadHashKeyAsync>d__124>(ref <ReadHashKeyAsync>d__);
			return <ReadHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteHashKey(System.String,System.String,System.String)" />
		// Token: 0x06001606 RID: 5638 RVA: 0x0007182C File Offset: 0x0006FA2C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteHashKeyAsync(string key, string field, string value)
		{
			RedisClientPool.<WriteHashKeyAsync>d__125 <WriteHashKeyAsync>d__ = new RedisClientPool.<WriteHashKeyAsync>d__125();
			<WriteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteHashKeyAsync>d__.<>4__this = this;
			<WriteHashKeyAsync>d__.key = key;
			<WriteHashKeyAsync>d__.field = field;
			<WriteHashKeyAsync>d__.value = value;
			<WriteHashKeyAsync>d__.<>1__state = -1;
			<WriteHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<WriteHashKeyAsync>d__125>(ref <WriteHashKeyAsync>d__);
			return <WriteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteHashKey(System.String,System.String[],System.String[])" />
		// Token: 0x06001607 RID: 5639 RVA: 0x00071888 File Offset: 0x0006FA88
		[DebuggerStepThrough]
		public Task<OperateResult> WriteHashKeyAsync(string key, string[] fields, string[] values)
		{
			RedisClientPool.<WriteHashKeyAsync>d__126 <WriteHashKeyAsync>d__ = new RedisClientPool.<WriteHashKeyAsync>d__126();
			<WriteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteHashKeyAsync>d__.<>4__this = this;
			<WriteHashKeyAsync>d__.key = key;
			<WriteHashKeyAsync>d__.fields = fields;
			<WriteHashKeyAsync>d__.values = values;
			<WriteHashKeyAsync>d__.<>1__state = -1;
			<WriteHashKeyAsync>d__.<>t__builder.Start<RedisClientPool.<WriteHashKeyAsync>d__126>(ref <WriteHashKeyAsync>d__);
			return <WriteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.WriteHashKeyNx(System.String,System.String,System.String)" />
		// Token: 0x06001608 RID: 5640 RVA: 0x000718E4 File Offset: 0x0006FAE4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteHashKeyNxAsync(string key, string field, string value)
		{
			RedisClientPool.<WriteHashKeyNxAsync>d__127 <WriteHashKeyNxAsync>d__ = new RedisClientPool.<WriteHashKeyNxAsync>d__127();
			<WriteHashKeyNxAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteHashKeyNxAsync>d__.<>4__this = this;
			<WriteHashKeyNxAsync>d__.key = key;
			<WriteHashKeyNxAsync>d__.field = field;
			<WriteHashKeyNxAsync>d__.value = value;
			<WriteHashKeyNxAsync>d__.<>1__state = -1;
			<WriteHashKeyNxAsync>d__.<>t__builder.Start<RedisClientPool.<WriteHashKeyNxAsync>d__127>(ref <WriteHashKeyNxAsync>d__);
			return <WriteHashKeyNxAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadHashValues(System.String)" />
		// Token: 0x06001609 RID: 5641 RVA: 0x00071940 File Offset: 0x0006FB40
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashValuesAsync(string key)
		{
			RedisClientPool.<ReadHashValuesAsync>d__128 <ReadHashValuesAsync>d__ = new RedisClientPool.<ReadHashValuesAsync>d__128();
			<ReadHashValuesAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashValuesAsync>d__.<>4__this = this;
			<ReadHashValuesAsync>d__.key = key;
			<ReadHashValuesAsync>d__.<>1__state = -1;
			<ReadHashValuesAsync>d__.<>t__builder.Start<RedisClientPool.<ReadHashValuesAsync>d__128>(ref <ReadHashValuesAsync>d__);
			return <ReadHashValuesAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetAdd(System.String,System.String)" />
		// Token: 0x0600160A RID: 5642 RVA: 0x0007198C File Offset: 0x0006FB8C
		public OperateResult<int> SetAdd(string key, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetAdd(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetAdd(System.String,System.String[])" />
		// Token: 0x0600160B RID: 5643 RVA: 0x000719C0 File Offset: 0x0006FBC0
		public OperateResult<int> SetAdd(string key, string[] members)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetAdd(key, members));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetCard(System.String)" />
		// Token: 0x0600160C RID: 5644 RVA: 0x000719F4 File Offset: 0x0006FBF4
		public OperateResult<int> SetCard(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetCard(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiff(System.String,System.String)" />
		// Token: 0x0600160D RID: 5645 RVA: 0x00071A20 File Offset: 0x0006FC20
		public OperateResult<string[]> SetDiff(string key, string diffKey)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetDiff(key, diffKey));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiff(System.String,System.String[])" />
		// Token: 0x0600160E RID: 5646 RVA: 0x00071A54 File Offset: 0x0006FC54
		public OperateResult<string[]> SetDiff(string key, string[] diffKeys)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetDiff(key, diffKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiffStore(System.String,System.String,System.String)" />
		// Token: 0x0600160F RID: 5647 RVA: 0x00071A88 File Offset: 0x0006FC88
		public OperateResult<int> SetDiffStore(string destination, string key, string diffKey)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetDiffStore(destination, key, diffKey));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiffStore(System.String,System.String,System.String[])" />
		// Token: 0x06001610 RID: 5648 RVA: 0x00071AC4 File Offset: 0x0006FCC4
		public OperateResult<int> SetDiffStore(string destination, string key, string[] diffKeys)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetDiffStore(destination, key, diffKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInter(System.String,System.String)" />
		// Token: 0x06001611 RID: 5649 RVA: 0x00071B00 File Offset: 0x0006FD00
		public OperateResult<string[]> SetInter(string key, string interKey)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetInter(key, interKey));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInter(System.String,System.String[])" />
		// Token: 0x06001612 RID: 5650 RVA: 0x00071B34 File Offset: 0x0006FD34
		public OperateResult<string[]> SetInter(string key, string[] interKeys)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetInter(key, interKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInterStore(System.String,System.String,System.String)" />
		// Token: 0x06001613 RID: 5651 RVA: 0x00071B68 File Offset: 0x0006FD68
		public OperateResult<int> SetInterStore(string destination, string key, string interKey)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetInterStore(destination, key, interKey));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInterStore(System.String,System.String,System.String[])" />
		// Token: 0x06001614 RID: 5652 RVA: 0x00071BA4 File Offset: 0x0006FDA4
		public OperateResult<int> SetInterStore(string destination, string key, string[] interKeys)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetInterStore(destination, key, interKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetIsMember(System.String,System.String)" />
		// Token: 0x06001615 RID: 5653 RVA: 0x00071BE0 File Offset: 0x0006FDE0
		public OperateResult<int> SetIsMember(string key, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetIsMember(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetMembers(System.String)" />
		// Token: 0x06001616 RID: 5654 RVA: 0x00071C14 File Offset: 0x0006FE14
		public OperateResult<string[]> SetMembers(string key)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetMembers(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetMove(System.String,System.String,System.String)" />
		// Token: 0x06001617 RID: 5655 RVA: 0x00071C40 File Offset: 0x0006FE40
		public OperateResult<int> SetMove(string source, string destination, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetMove(source, destination, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetPop(System.String)" />
		// Token: 0x06001618 RID: 5656 RVA: 0x00071C7C File Offset: 0x0006FE7C
		public OperateResult<string> SetPop(string key)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.SetPop(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRandomMember(System.String)" />
		// Token: 0x06001619 RID: 5657 RVA: 0x00071CA8 File Offset: 0x0006FEA8
		public OperateResult<string> SetRandomMember(string key)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.SetRandomMember(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRandomMember(System.String,System.Int32)" />
		// Token: 0x0600161A RID: 5658 RVA: 0x00071CD4 File Offset: 0x0006FED4
		public OperateResult<string[]> SetRandomMember(string key, int count)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetRandomMember(key, count));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRemove(System.String,System.String)" />
		// Token: 0x0600161B RID: 5659 RVA: 0x00071D08 File Offset: 0x0006FF08
		public OperateResult<int> SetRemove(string key, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetRemove(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRemove(System.String,System.String[])" />
		// Token: 0x0600161C RID: 5660 RVA: 0x00071D3C File Offset: 0x0006FF3C
		public OperateResult<int> SetRemove(string key, string[] members)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetRemove(key, members));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnion(System.String,System.String)" />
		// Token: 0x0600161D RID: 5661 RVA: 0x00071D70 File Offset: 0x0006FF70
		public OperateResult<string[]> SetUnion(string key, string unionKey)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetUnion(key, unionKey));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnion(System.String,System.String[])" />
		// Token: 0x0600161E RID: 5662 RVA: 0x00071DA4 File Offset: 0x0006FFA4
		public OperateResult<string[]> SetUnion(string key, string[] unionKeys)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.SetUnion(key, unionKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnionStore(System.String,System.String,System.String)" />
		// Token: 0x0600161F RID: 5663 RVA: 0x00071DD8 File Offset: 0x0006FFD8
		public OperateResult<int> SetUnionStore(string destination, string key, string unionKey)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetUnionStore(destination, key, unionKey));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnionStore(System.String,System.String,System.String[])" />
		// Token: 0x06001620 RID: 5664 RVA: 0x00071E14 File Offset: 0x00070014
		public OperateResult<int> SetUnionStore(string destination, string key, string[] unionKeys)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.SetUnionStore(destination, key, unionKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetAdd(System.String,System.String)" />
		// Token: 0x06001621 RID: 5665 RVA: 0x00071E50 File Offset: 0x00070050
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetAddAsync(string key, string member)
		{
			RedisClientPool.<SetAddAsync>d__152 <SetAddAsync>d__ = new RedisClientPool.<SetAddAsync>d__152();
			<SetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetAddAsync>d__.<>4__this = this;
			<SetAddAsync>d__.key = key;
			<SetAddAsync>d__.member = member;
			<SetAddAsync>d__.<>1__state = -1;
			<SetAddAsync>d__.<>t__builder.Start<RedisClientPool.<SetAddAsync>d__152>(ref <SetAddAsync>d__);
			return <SetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetAdd(System.String,System.String[])" />
		// Token: 0x06001622 RID: 5666 RVA: 0x00071EA4 File Offset: 0x000700A4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetAddAsync(string key, string[] members)
		{
			RedisClientPool.<SetAddAsync>d__153 <SetAddAsync>d__ = new RedisClientPool.<SetAddAsync>d__153();
			<SetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetAddAsync>d__.<>4__this = this;
			<SetAddAsync>d__.key = key;
			<SetAddAsync>d__.members = members;
			<SetAddAsync>d__.<>1__state = -1;
			<SetAddAsync>d__.<>t__builder.Start<RedisClientPool.<SetAddAsync>d__153>(ref <SetAddAsync>d__);
			return <SetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetCard(System.String)" />
		// Token: 0x06001623 RID: 5667 RVA: 0x00071EF8 File Offset: 0x000700F8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetCardAsync(string key)
		{
			RedisClientPool.<SetCardAsync>d__154 <SetCardAsync>d__ = new RedisClientPool.<SetCardAsync>d__154();
			<SetCardAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetCardAsync>d__.<>4__this = this;
			<SetCardAsync>d__.key = key;
			<SetCardAsync>d__.<>1__state = -1;
			<SetCardAsync>d__.<>t__builder.Start<RedisClientPool.<SetCardAsync>d__154>(ref <SetCardAsync>d__);
			return <SetCardAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetDiff(System.String,System.String)" />
		// Token: 0x06001624 RID: 5668 RVA: 0x00071F44 File Offset: 0x00070144
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetDiffAsync(string key, string diffKey)
		{
			RedisClientPool.<SetDiffAsync>d__155 <SetDiffAsync>d__ = new RedisClientPool.<SetDiffAsync>d__155();
			<SetDiffAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetDiffAsync>d__.<>4__this = this;
			<SetDiffAsync>d__.key = key;
			<SetDiffAsync>d__.diffKey = diffKey;
			<SetDiffAsync>d__.<>1__state = -1;
			<SetDiffAsync>d__.<>t__builder.Start<RedisClientPool.<SetDiffAsync>d__155>(ref <SetDiffAsync>d__);
			return <SetDiffAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetDiff(System.String,System.String[])" />
		// Token: 0x06001625 RID: 5669 RVA: 0x00071F98 File Offset: 0x00070198
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetDiffAsync(string key, string[] diffKeys)
		{
			RedisClientPool.<SetDiffAsync>d__156 <SetDiffAsync>d__ = new RedisClientPool.<SetDiffAsync>d__156();
			<SetDiffAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetDiffAsync>d__.<>4__this = this;
			<SetDiffAsync>d__.key = key;
			<SetDiffAsync>d__.diffKeys = diffKeys;
			<SetDiffAsync>d__.<>1__state = -1;
			<SetDiffAsync>d__.<>t__builder.Start<RedisClientPool.<SetDiffAsync>d__156>(ref <SetDiffAsync>d__);
			return <SetDiffAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetDiffStore(System.String,System.String,System.String)" />
		// Token: 0x06001626 RID: 5670 RVA: 0x00071FEC File Offset: 0x000701EC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetDiffStoreAsync(string destination, string key, string diffKey)
		{
			RedisClientPool.<SetDiffStoreAsync>d__157 <SetDiffStoreAsync>d__ = new RedisClientPool.<SetDiffStoreAsync>d__157();
			<SetDiffStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetDiffStoreAsync>d__.<>4__this = this;
			<SetDiffStoreAsync>d__.destination = destination;
			<SetDiffStoreAsync>d__.key = key;
			<SetDiffStoreAsync>d__.diffKey = diffKey;
			<SetDiffStoreAsync>d__.<>1__state = -1;
			<SetDiffStoreAsync>d__.<>t__builder.Start<RedisClientPool.<SetDiffStoreAsync>d__157>(ref <SetDiffStoreAsync>d__);
			return <SetDiffStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetDiffStore(System.String,System.String,System.String[])" />
		// Token: 0x06001627 RID: 5671 RVA: 0x00072048 File Offset: 0x00070248
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetDiffStoreAsync(string destination, string key, string[] diffKeys)
		{
			RedisClientPool.<SetDiffStoreAsync>d__158 <SetDiffStoreAsync>d__ = new RedisClientPool.<SetDiffStoreAsync>d__158();
			<SetDiffStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetDiffStoreAsync>d__.<>4__this = this;
			<SetDiffStoreAsync>d__.destination = destination;
			<SetDiffStoreAsync>d__.key = key;
			<SetDiffStoreAsync>d__.diffKeys = diffKeys;
			<SetDiffStoreAsync>d__.<>1__state = -1;
			<SetDiffStoreAsync>d__.<>t__builder.Start<RedisClientPool.<SetDiffStoreAsync>d__158>(ref <SetDiffStoreAsync>d__);
			return <SetDiffStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetInter(System.String,System.String)" />
		// Token: 0x06001628 RID: 5672 RVA: 0x000720A4 File Offset: 0x000702A4
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetInterAsync(string key, string interKey)
		{
			RedisClientPool.<SetInterAsync>d__159 <SetInterAsync>d__ = new RedisClientPool.<SetInterAsync>d__159();
			<SetInterAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetInterAsync>d__.<>4__this = this;
			<SetInterAsync>d__.key = key;
			<SetInterAsync>d__.interKey = interKey;
			<SetInterAsync>d__.<>1__state = -1;
			<SetInterAsync>d__.<>t__builder.Start<RedisClientPool.<SetInterAsync>d__159>(ref <SetInterAsync>d__);
			return <SetInterAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetInter(System.String,System.String[])" />
		// Token: 0x06001629 RID: 5673 RVA: 0x000720F8 File Offset: 0x000702F8
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetInterAsync(string key, string[] interKeys)
		{
			RedisClientPool.<SetInterAsync>d__160 <SetInterAsync>d__ = new RedisClientPool.<SetInterAsync>d__160();
			<SetInterAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetInterAsync>d__.<>4__this = this;
			<SetInterAsync>d__.key = key;
			<SetInterAsync>d__.interKeys = interKeys;
			<SetInterAsync>d__.<>1__state = -1;
			<SetInterAsync>d__.<>t__builder.Start<RedisClientPool.<SetInterAsync>d__160>(ref <SetInterAsync>d__);
			return <SetInterAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetInterStore(System.String,System.String,System.String)" />
		// Token: 0x0600162A RID: 5674 RVA: 0x0007214C File Offset: 0x0007034C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetInterStoreAsync(string destination, string key, string interKey)
		{
			RedisClientPool.<SetInterStoreAsync>d__161 <SetInterStoreAsync>d__ = new RedisClientPool.<SetInterStoreAsync>d__161();
			<SetInterStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetInterStoreAsync>d__.<>4__this = this;
			<SetInterStoreAsync>d__.destination = destination;
			<SetInterStoreAsync>d__.key = key;
			<SetInterStoreAsync>d__.interKey = interKey;
			<SetInterStoreAsync>d__.<>1__state = -1;
			<SetInterStoreAsync>d__.<>t__builder.Start<RedisClientPool.<SetInterStoreAsync>d__161>(ref <SetInterStoreAsync>d__);
			return <SetInterStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetInterStore(System.String,System.String,System.String[])" />
		// Token: 0x0600162B RID: 5675 RVA: 0x000721A8 File Offset: 0x000703A8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetInterStoreAsync(string destination, string key, string[] interKeys)
		{
			RedisClientPool.<SetInterStoreAsync>d__162 <SetInterStoreAsync>d__ = new RedisClientPool.<SetInterStoreAsync>d__162();
			<SetInterStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetInterStoreAsync>d__.<>4__this = this;
			<SetInterStoreAsync>d__.destination = destination;
			<SetInterStoreAsync>d__.key = key;
			<SetInterStoreAsync>d__.interKeys = interKeys;
			<SetInterStoreAsync>d__.<>1__state = -1;
			<SetInterStoreAsync>d__.<>t__builder.Start<RedisClientPool.<SetInterStoreAsync>d__162>(ref <SetInterStoreAsync>d__);
			return <SetInterStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetIsMember(System.String,System.String)" />
		// Token: 0x0600162C RID: 5676 RVA: 0x00072204 File Offset: 0x00070404
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetIsMemberAsync(string key, string member)
		{
			RedisClientPool.<SetIsMemberAsync>d__163 <SetIsMemberAsync>d__ = new RedisClientPool.<SetIsMemberAsync>d__163();
			<SetIsMemberAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetIsMemberAsync>d__.<>4__this = this;
			<SetIsMemberAsync>d__.key = key;
			<SetIsMemberAsync>d__.member = member;
			<SetIsMemberAsync>d__.<>1__state = -1;
			<SetIsMemberAsync>d__.<>t__builder.Start<RedisClientPool.<SetIsMemberAsync>d__163>(ref <SetIsMemberAsync>d__);
			return <SetIsMemberAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetMembers(System.String)" />
		// Token: 0x0600162D RID: 5677 RVA: 0x00072258 File Offset: 0x00070458
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetMembersAsync(string key)
		{
			RedisClientPool.<SetMembersAsync>d__164 <SetMembersAsync>d__ = new RedisClientPool.<SetMembersAsync>d__164();
			<SetMembersAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetMembersAsync>d__.<>4__this = this;
			<SetMembersAsync>d__.key = key;
			<SetMembersAsync>d__.<>1__state = -1;
			<SetMembersAsync>d__.<>t__builder.Start<RedisClientPool.<SetMembersAsync>d__164>(ref <SetMembersAsync>d__);
			return <SetMembersAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetMove(System.String,System.String,System.String)" />
		// Token: 0x0600162E RID: 5678 RVA: 0x000722A4 File Offset: 0x000704A4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetMoveAsync(string source, string destination, string member)
		{
			RedisClientPool.<SetMoveAsync>d__165 <SetMoveAsync>d__ = new RedisClientPool.<SetMoveAsync>d__165();
			<SetMoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetMoveAsync>d__.<>4__this = this;
			<SetMoveAsync>d__.source = source;
			<SetMoveAsync>d__.destination = destination;
			<SetMoveAsync>d__.member = member;
			<SetMoveAsync>d__.<>1__state = -1;
			<SetMoveAsync>d__.<>t__builder.Start<RedisClientPool.<SetMoveAsync>d__165>(ref <SetMoveAsync>d__);
			return <SetMoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetPop(System.String)" />
		// Token: 0x0600162F RID: 5679 RVA: 0x00072300 File Offset: 0x00070500
		[DebuggerStepThrough]
		public Task<OperateResult<string>> SetPopAsync(string key)
		{
			RedisClientPool.<SetPopAsync>d__166 <SetPopAsync>d__ = new RedisClientPool.<SetPopAsync>d__166();
			<SetPopAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<SetPopAsync>d__.<>4__this = this;
			<SetPopAsync>d__.key = key;
			<SetPopAsync>d__.<>1__state = -1;
			<SetPopAsync>d__.<>t__builder.Start<RedisClientPool.<SetPopAsync>d__166>(ref <SetPopAsync>d__);
			return <SetPopAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetRandomMember(System.String)" />
		// Token: 0x06001630 RID: 5680 RVA: 0x0007234C File Offset: 0x0007054C
		[DebuggerStepThrough]
		public Task<OperateResult<string>> SetRandomMemberAsync(string key)
		{
			RedisClientPool.<SetRandomMemberAsync>d__167 <SetRandomMemberAsync>d__ = new RedisClientPool.<SetRandomMemberAsync>d__167();
			<SetRandomMemberAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<SetRandomMemberAsync>d__.<>4__this = this;
			<SetRandomMemberAsync>d__.key = key;
			<SetRandomMemberAsync>d__.<>1__state = -1;
			<SetRandomMemberAsync>d__.<>t__builder.Start<RedisClientPool.<SetRandomMemberAsync>d__167>(ref <SetRandomMemberAsync>d__);
			return <SetRandomMemberAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetRandomMember(System.String,System.Int32)" />
		// Token: 0x06001631 RID: 5681 RVA: 0x00072398 File Offset: 0x00070598
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetRandomMemberAsync(string key, int count)
		{
			RedisClientPool.<SetRandomMemberAsync>d__168 <SetRandomMemberAsync>d__ = new RedisClientPool.<SetRandomMemberAsync>d__168();
			<SetRandomMemberAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetRandomMemberAsync>d__.<>4__this = this;
			<SetRandomMemberAsync>d__.key = key;
			<SetRandomMemberAsync>d__.count = count;
			<SetRandomMemberAsync>d__.<>1__state = -1;
			<SetRandomMemberAsync>d__.<>t__builder.Start<RedisClientPool.<SetRandomMemberAsync>d__168>(ref <SetRandomMemberAsync>d__);
			return <SetRandomMemberAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetRemove(System.String,System.String)" />
		// Token: 0x06001632 RID: 5682 RVA: 0x000723EC File Offset: 0x000705EC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetRemoveAsync(string key, string member)
		{
			RedisClientPool.<SetRemoveAsync>d__169 <SetRemoveAsync>d__ = new RedisClientPool.<SetRemoveAsync>d__169();
			<SetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetRemoveAsync>d__.<>4__this = this;
			<SetRemoveAsync>d__.key = key;
			<SetRemoveAsync>d__.member = member;
			<SetRemoveAsync>d__.<>1__state = -1;
			<SetRemoveAsync>d__.<>t__builder.Start<RedisClientPool.<SetRemoveAsync>d__169>(ref <SetRemoveAsync>d__);
			return <SetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetRemove(System.String,System.String[])" />
		// Token: 0x06001633 RID: 5683 RVA: 0x00072440 File Offset: 0x00070640
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetRemoveAsync(string key, string[] members)
		{
			RedisClientPool.<SetRemoveAsync>d__170 <SetRemoveAsync>d__ = new RedisClientPool.<SetRemoveAsync>d__170();
			<SetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetRemoveAsync>d__.<>4__this = this;
			<SetRemoveAsync>d__.key = key;
			<SetRemoveAsync>d__.members = members;
			<SetRemoveAsync>d__.<>1__state = -1;
			<SetRemoveAsync>d__.<>t__builder.Start<RedisClientPool.<SetRemoveAsync>d__170>(ref <SetRemoveAsync>d__);
			return <SetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetUnion(System.String,System.String)" />
		// Token: 0x06001634 RID: 5684 RVA: 0x00072494 File Offset: 0x00070694
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetUnionAsync(string key, string unionKey)
		{
			RedisClientPool.<SetUnionAsync>d__171 <SetUnionAsync>d__ = new RedisClientPool.<SetUnionAsync>d__171();
			<SetUnionAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetUnionAsync>d__.<>4__this = this;
			<SetUnionAsync>d__.key = key;
			<SetUnionAsync>d__.unionKey = unionKey;
			<SetUnionAsync>d__.<>1__state = -1;
			<SetUnionAsync>d__.<>t__builder.Start<RedisClientPool.<SetUnionAsync>d__171>(ref <SetUnionAsync>d__);
			return <SetUnionAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetUnion(System.String,System.String[])" />
		// Token: 0x06001635 RID: 5685 RVA: 0x000724E8 File Offset: 0x000706E8
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetUnionAsync(string key, string[] unionKeys)
		{
			RedisClientPool.<SetUnionAsync>d__172 <SetUnionAsync>d__ = new RedisClientPool.<SetUnionAsync>d__172();
			<SetUnionAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetUnionAsync>d__.<>4__this = this;
			<SetUnionAsync>d__.key = key;
			<SetUnionAsync>d__.unionKeys = unionKeys;
			<SetUnionAsync>d__.<>1__state = -1;
			<SetUnionAsync>d__.<>t__builder.Start<RedisClientPool.<SetUnionAsync>d__172>(ref <SetUnionAsync>d__);
			return <SetUnionAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetUnionStore(System.String,System.String,System.String)" />
		// Token: 0x06001636 RID: 5686 RVA: 0x0007253C File Offset: 0x0007073C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetUnionStoreAsync(string destination, string key, string unionKey)
		{
			RedisClientPool.<SetUnionStoreAsync>d__173 <SetUnionStoreAsync>d__ = new RedisClientPool.<SetUnionStoreAsync>d__173();
			<SetUnionStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetUnionStoreAsync>d__.<>4__this = this;
			<SetUnionStoreAsync>d__.destination = destination;
			<SetUnionStoreAsync>d__.key = key;
			<SetUnionStoreAsync>d__.unionKey = unionKey;
			<SetUnionStoreAsync>d__.<>1__state = -1;
			<SetUnionStoreAsync>d__.<>t__builder.Start<RedisClientPool.<SetUnionStoreAsync>d__173>(ref <SetUnionStoreAsync>d__);
			return <SetUnionStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SetUnionStore(System.String,System.String,System.String[])" />
		// Token: 0x06001637 RID: 5687 RVA: 0x00072598 File Offset: 0x00070798
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetUnionStoreAsync(string destination, string key, string[] unionKeys)
		{
			RedisClientPool.<SetUnionStoreAsync>d__174 <SetUnionStoreAsync>d__ = new RedisClientPool.<SetUnionStoreAsync>d__174();
			<SetUnionStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetUnionStoreAsync>d__.<>4__this = this;
			<SetUnionStoreAsync>d__.destination = destination;
			<SetUnionStoreAsync>d__.key = key;
			<SetUnionStoreAsync>d__.unionKeys = unionKeys;
			<SetUnionStoreAsync>d__.<>1__state = -1;
			<SetUnionStoreAsync>d__.<>t__builder.Start<RedisClientPool.<SetUnionStoreAsync>d__174>(ref <SetUnionStoreAsync>d__);
			return <SetUnionStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetAdd(System.String,System.String,System.Double)" />
		// Token: 0x06001638 RID: 5688 RVA: 0x000725F4 File Offset: 0x000707F4
		public OperateResult<int> ZSetAdd(string key, string member, double score)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetAdd(key, member, score));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetAdd(System.String,System.String[],System.Double[])" />
		// Token: 0x06001639 RID: 5689 RVA: 0x00072630 File Offset: 0x00070830
		public OperateResult<int> ZSetAdd(string key, string[] members, double[] scores)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetAdd(key, members, scores));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetCard(System.String)" />
		// Token: 0x0600163A RID: 5690 RVA: 0x0007266C File Offset: 0x0007086C
		public OperateResult<int> ZSetCard(string key)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetCard(key));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetCount(System.String,System.Double,System.Double)" />
		// Token: 0x0600163B RID: 5691 RVA: 0x00072698 File Offset: 0x00070898
		public OperateResult<int> ZSetCount(string key, double min, double max)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetCount(key, min, max));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetIncreaseBy(System.String,System.String,System.Double)" />
		// Token: 0x0600163C RID: 5692 RVA: 0x000726D4 File Offset: 0x000708D4
		public OperateResult<string> ZSetIncreaseBy(string key, string member, double increment)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ZSetIncreaseBy(key, member, increment));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRange(System.String,System.Int32,System.Int32,System.Boolean)" />
		// Token: 0x0600163D RID: 5693 RVA: 0x00072710 File Offset: 0x00070910
		public OperateResult<string[]> ZSetRange(string key, int start, int stop, bool withScore = false)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ZSetRange(key, start, stop, withScore));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRangeByScore(System.String,System.String,System.String,System.Boolean)" />
		// Token: 0x0600163E RID: 5694 RVA: 0x00072754 File Offset: 0x00070954
		public OperateResult<string[]> ZSetRangeByScore(string key, string min, string max, bool withScore = false)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ZSetRangeByScore(key, min, max, withScore));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRank(System.String,System.String)" />
		// Token: 0x0600163F RID: 5695 RVA: 0x00072798 File Offset: 0x00070998
		public OperateResult<int> ZSetRank(string key, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetRank(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemove(System.String,System.String)" />
		// Token: 0x06001640 RID: 5696 RVA: 0x000727CC File Offset: 0x000709CC
		public OperateResult<int> ZSetRemove(string key, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetRemove(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemove(System.String,System.String[])" />
		// Token: 0x06001641 RID: 5697 RVA: 0x00072800 File Offset: 0x00070A00
		public OperateResult<int> ZSetRemove(string key, string[] members)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetRemove(key, members));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemoveRangeByRank(System.String,System.Int32,System.Int32)" />
		// Token: 0x06001642 RID: 5698 RVA: 0x00072834 File Offset: 0x00070A34
		public OperateResult<int> ZSetRemoveRangeByRank(string key, int start, int stop)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetRemoveRangeByRank(key, start, stop));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemoveRangeByScore(System.String,System.String,System.String)" />
		// Token: 0x06001643 RID: 5699 RVA: 0x00072870 File Offset: 0x00070A70
		public OperateResult<int> ZSetRemoveRangeByScore(string key, string min, string max)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetRemoveRangeByScore(key, min, max));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetReverseRange(System.String,System.Int32,System.Int32,System.Boolean)" />
		// Token: 0x06001644 RID: 5700 RVA: 0x000728AC File Offset: 0x00070AAC
		public OperateResult<string[]> ZSetReverseRange(string key, int start, int stop, bool withScore = false)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ZSetReverseRange(key, start, stop, withScore));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetReverseRangeByScore(System.String,System.String,System.String,System.Boolean)" />
		// Token: 0x06001645 RID: 5701 RVA: 0x000728F0 File Offset: 0x00070AF0
		public OperateResult<string[]> ZSetReverseRangeByScore(string key, string max, string min, bool withScore = false)
		{
			return this.ConnectPoolExecute<string[]>((RedisClient m) => m.ZSetReverseRangeByScore(key, max, min, withScore));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetReverseRank(System.String,System.String)" />
		// Token: 0x06001646 RID: 5702 RVA: 0x00072934 File Offset: 0x00070B34
		public OperateResult<int> ZSetReverseRank(string key, string member)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.ZSetReverseRank(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetScore(System.String,System.String)" />
		// Token: 0x06001647 RID: 5703 RVA: 0x00072968 File Offset: 0x00070B68
		public OperateResult<string> ZSetScore(string key, string member)
		{
			return this.ConnectPoolExecute<string>((RedisClient m) => m.ZSetScore(key, member));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetAdd(System.String,System.String,System.Double)" />
		// Token: 0x06001648 RID: 5704 RVA: 0x0007299C File Offset: 0x00070B9C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetAddAsync(string key, string member, double score)
		{
			RedisClientPool.<ZSetAddAsync>d__191 <ZSetAddAsync>d__ = new RedisClientPool.<ZSetAddAsync>d__191();
			<ZSetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetAddAsync>d__.<>4__this = this;
			<ZSetAddAsync>d__.key = key;
			<ZSetAddAsync>d__.member = member;
			<ZSetAddAsync>d__.score = score;
			<ZSetAddAsync>d__.<>1__state = -1;
			<ZSetAddAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetAddAsync>d__191>(ref <ZSetAddAsync>d__);
			return <ZSetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetAdd(System.String,System.String[],System.Double[])" />
		// Token: 0x06001649 RID: 5705 RVA: 0x000729F8 File Offset: 0x00070BF8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetAddAsync(string key, string[] members, double[] scores)
		{
			RedisClientPool.<ZSetAddAsync>d__192 <ZSetAddAsync>d__ = new RedisClientPool.<ZSetAddAsync>d__192();
			<ZSetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetAddAsync>d__.<>4__this = this;
			<ZSetAddAsync>d__.key = key;
			<ZSetAddAsync>d__.members = members;
			<ZSetAddAsync>d__.scores = scores;
			<ZSetAddAsync>d__.<>1__state = -1;
			<ZSetAddAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetAddAsync>d__192>(ref <ZSetAddAsync>d__);
			return <ZSetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetCard(System.String)" />
		// Token: 0x0600164A RID: 5706 RVA: 0x00072A54 File Offset: 0x00070C54
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetCardAsync(string key)
		{
			RedisClientPool.<ZSetCardAsync>d__193 <ZSetCardAsync>d__ = new RedisClientPool.<ZSetCardAsync>d__193();
			<ZSetCardAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetCardAsync>d__.<>4__this = this;
			<ZSetCardAsync>d__.key = key;
			<ZSetCardAsync>d__.<>1__state = -1;
			<ZSetCardAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetCardAsync>d__193>(ref <ZSetCardAsync>d__);
			return <ZSetCardAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetCount(System.String,System.Double,System.Double)" />
		// Token: 0x0600164B RID: 5707 RVA: 0x00072AA0 File Offset: 0x00070CA0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetCountAsync(string key, double min, double max)
		{
			RedisClientPool.<ZSetCountAsync>d__194 <ZSetCountAsync>d__ = new RedisClientPool.<ZSetCountAsync>d__194();
			<ZSetCountAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetCountAsync>d__.<>4__this = this;
			<ZSetCountAsync>d__.key = key;
			<ZSetCountAsync>d__.min = min;
			<ZSetCountAsync>d__.max = max;
			<ZSetCountAsync>d__.<>1__state = -1;
			<ZSetCountAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetCountAsync>d__194>(ref <ZSetCountAsync>d__);
			return <ZSetCountAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetIncreaseBy(System.String,System.String,System.Double)" />
		// Token: 0x0600164C RID: 5708 RVA: 0x00072AFC File Offset: 0x00070CFC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ZSetIncreaseByAsync(string key, string member, double increment)
		{
			RedisClientPool.<ZSetIncreaseByAsync>d__195 <ZSetIncreaseByAsync>d__ = new RedisClientPool.<ZSetIncreaseByAsync>d__195();
			<ZSetIncreaseByAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ZSetIncreaseByAsync>d__.<>4__this = this;
			<ZSetIncreaseByAsync>d__.key = key;
			<ZSetIncreaseByAsync>d__.member = member;
			<ZSetIncreaseByAsync>d__.increment = increment;
			<ZSetIncreaseByAsync>d__.<>1__state = -1;
			<ZSetIncreaseByAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetIncreaseByAsync>d__195>(ref <ZSetIncreaseByAsync>d__);
			return <ZSetIncreaseByAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRange(System.String,System.Int32,System.Int32,System.Boolean)" />
		// Token: 0x0600164D RID: 5709 RVA: 0x00072B58 File Offset: 0x00070D58
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetRangeAsync(string key, int start, int stop, bool withScore = false)
		{
			RedisClientPool.<ZSetRangeAsync>d__196 <ZSetRangeAsync>d__ = new RedisClientPool.<ZSetRangeAsync>d__196();
			<ZSetRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetRangeAsync>d__.<>4__this = this;
			<ZSetRangeAsync>d__.key = key;
			<ZSetRangeAsync>d__.start = start;
			<ZSetRangeAsync>d__.stop = stop;
			<ZSetRangeAsync>d__.withScore = withScore;
			<ZSetRangeAsync>d__.<>1__state = -1;
			<ZSetRangeAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRangeAsync>d__196>(ref <ZSetRangeAsync>d__);
			return <ZSetRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRangeByScore(System.String,System.String,System.String,System.Boolean)" />
		// Token: 0x0600164E RID: 5710 RVA: 0x00072BBC File Offset: 0x00070DBC
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetRangeByScoreAsync(string key, string min, string max, bool withScore = false)
		{
			RedisClientPool.<ZSetRangeByScoreAsync>d__197 <ZSetRangeByScoreAsync>d__ = new RedisClientPool.<ZSetRangeByScoreAsync>d__197();
			<ZSetRangeByScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetRangeByScoreAsync>d__.<>4__this = this;
			<ZSetRangeByScoreAsync>d__.key = key;
			<ZSetRangeByScoreAsync>d__.min = min;
			<ZSetRangeByScoreAsync>d__.max = max;
			<ZSetRangeByScoreAsync>d__.withScore = withScore;
			<ZSetRangeByScoreAsync>d__.<>1__state = -1;
			<ZSetRangeByScoreAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRangeByScoreAsync>d__197>(ref <ZSetRangeByScoreAsync>d__);
			return <ZSetRangeByScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRank(System.String,System.String)" />
		// Token: 0x0600164F RID: 5711 RVA: 0x00072C20 File Offset: 0x00070E20
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRankAsync(string key, string member)
		{
			RedisClientPool.<ZSetRankAsync>d__198 <ZSetRankAsync>d__ = new RedisClientPool.<ZSetRankAsync>d__198();
			<ZSetRankAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRankAsync>d__.<>4__this = this;
			<ZSetRankAsync>d__.key = key;
			<ZSetRankAsync>d__.member = member;
			<ZSetRankAsync>d__.<>1__state = -1;
			<ZSetRankAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRankAsync>d__198>(ref <ZSetRankAsync>d__);
			return <ZSetRankAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRemove(System.String,System.String)" />
		// Token: 0x06001650 RID: 5712 RVA: 0x00072C74 File Offset: 0x00070E74
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveAsync(string key, string member)
		{
			RedisClientPool.<ZSetRemoveAsync>d__199 <ZSetRemoveAsync>d__ = new RedisClientPool.<ZSetRemoveAsync>d__199();
			<ZSetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveAsync>d__.<>4__this = this;
			<ZSetRemoveAsync>d__.key = key;
			<ZSetRemoveAsync>d__.member = member;
			<ZSetRemoveAsync>d__.<>1__state = -1;
			<ZSetRemoveAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRemoveAsync>d__199>(ref <ZSetRemoveAsync>d__);
			return <ZSetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRemove(System.String,System.String[])" />
		// Token: 0x06001651 RID: 5713 RVA: 0x00072CC8 File Offset: 0x00070EC8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveAsync(string key, string[] members)
		{
			RedisClientPool.<ZSetRemoveAsync>d__200 <ZSetRemoveAsync>d__ = new RedisClientPool.<ZSetRemoveAsync>d__200();
			<ZSetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveAsync>d__.<>4__this = this;
			<ZSetRemoveAsync>d__.key = key;
			<ZSetRemoveAsync>d__.members = members;
			<ZSetRemoveAsync>d__.<>1__state = -1;
			<ZSetRemoveAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRemoveAsync>d__200>(ref <ZSetRemoveAsync>d__);
			return <ZSetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRemoveRangeByRank(System.String,System.Int32,System.Int32)" />
		// Token: 0x06001652 RID: 5714 RVA: 0x00072D1C File Offset: 0x00070F1C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveRangeByRankAsync(string key, int start, int stop)
		{
			RedisClientPool.<ZSetRemoveRangeByRankAsync>d__201 <ZSetRemoveRangeByRankAsync>d__ = new RedisClientPool.<ZSetRemoveRangeByRankAsync>d__201();
			<ZSetRemoveRangeByRankAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveRangeByRankAsync>d__.<>4__this = this;
			<ZSetRemoveRangeByRankAsync>d__.key = key;
			<ZSetRemoveRangeByRankAsync>d__.start = start;
			<ZSetRemoveRangeByRankAsync>d__.stop = stop;
			<ZSetRemoveRangeByRankAsync>d__.<>1__state = -1;
			<ZSetRemoveRangeByRankAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRemoveRangeByRankAsync>d__201>(ref <ZSetRemoveRangeByRankAsync>d__);
			return <ZSetRemoveRangeByRankAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetRemoveRangeByScore(System.String,System.String,System.String)" />
		// Token: 0x06001653 RID: 5715 RVA: 0x00072D78 File Offset: 0x00070F78
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveRangeByScoreAsync(string key, string min, string max)
		{
			RedisClientPool.<ZSetRemoveRangeByScoreAsync>d__202 <ZSetRemoveRangeByScoreAsync>d__ = new RedisClientPool.<ZSetRemoveRangeByScoreAsync>d__202();
			<ZSetRemoveRangeByScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveRangeByScoreAsync>d__.<>4__this = this;
			<ZSetRemoveRangeByScoreAsync>d__.key = key;
			<ZSetRemoveRangeByScoreAsync>d__.min = min;
			<ZSetRemoveRangeByScoreAsync>d__.max = max;
			<ZSetRemoveRangeByScoreAsync>d__.<>1__state = -1;
			<ZSetRemoveRangeByScoreAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetRemoveRangeByScoreAsync>d__202>(ref <ZSetRemoveRangeByScoreAsync>d__);
			return <ZSetRemoveRangeByScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetReverseRange(System.String,System.Int32,System.Int32,System.Boolean)" />
		// Token: 0x06001654 RID: 5716 RVA: 0x00072DD4 File Offset: 0x00070FD4
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetReverseRangeAsync(string key, int start, int stop, bool withScore = false)
		{
			RedisClientPool.<ZSetReverseRangeAsync>d__203 <ZSetReverseRangeAsync>d__ = new RedisClientPool.<ZSetReverseRangeAsync>d__203();
			<ZSetReverseRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetReverseRangeAsync>d__.<>4__this = this;
			<ZSetReverseRangeAsync>d__.key = key;
			<ZSetReverseRangeAsync>d__.start = start;
			<ZSetReverseRangeAsync>d__.stop = stop;
			<ZSetReverseRangeAsync>d__.withScore = withScore;
			<ZSetReverseRangeAsync>d__.<>1__state = -1;
			<ZSetReverseRangeAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetReverseRangeAsync>d__203>(ref <ZSetReverseRangeAsync>d__);
			return <ZSetReverseRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetReverseRangeByScore(System.String,System.String,System.String,System.Boolean)" />
		// Token: 0x06001655 RID: 5717 RVA: 0x00072E38 File Offset: 0x00071038
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetReverseRangeByScoreAsync(string key, string max, string min, bool withScore = false)
		{
			RedisClientPool.<ZSetReverseRangeByScoreAsync>d__204 <ZSetReverseRangeByScoreAsync>d__ = new RedisClientPool.<ZSetReverseRangeByScoreAsync>d__204();
			<ZSetReverseRangeByScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetReverseRangeByScoreAsync>d__.<>4__this = this;
			<ZSetReverseRangeByScoreAsync>d__.key = key;
			<ZSetReverseRangeByScoreAsync>d__.max = max;
			<ZSetReverseRangeByScoreAsync>d__.min = min;
			<ZSetReverseRangeByScoreAsync>d__.withScore = withScore;
			<ZSetReverseRangeByScoreAsync>d__.<>1__state = -1;
			<ZSetReverseRangeByScoreAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetReverseRangeByScoreAsync>d__204>(ref <ZSetReverseRangeByScoreAsync>d__);
			return <ZSetReverseRangeByScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetReverseRank(System.String,System.String)" />
		// Token: 0x06001656 RID: 5718 RVA: 0x00072E9C File Offset: 0x0007109C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetReverseRankAsync(string key, string member)
		{
			RedisClientPool.<ZSetReverseRankAsync>d__205 <ZSetReverseRankAsync>d__ = new RedisClientPool.<ZSetReverseRankAsync>d__205();
			<ZSetReverseRankAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetReverseRankAsync>d__.<>4__this = this;
			<ZSetReverseRankAsync>d__.key = key;
			<ZSetReverseRankAsync>d__.member = member;
			<ZSetReverseRankAsync>d__.<>1__state = -1;
			<ZSetReverseRankAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetReverseRankAsync>d__205>(ref <ZSetReverseRankAsync>d__);
			return <ZSetReverseRankAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ZSetScore(System.String,System.String)" />
		// Token: 0x06001657 RID: 5719 RVA: 0x00072EF0 File Offset: 0x000710F0
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ZSetScoreAsync(string key, string member)
		{
			RedisClientPool.<ZSetScoreAsync>d__206 <ZSetScoreAsync>d__ = new RedisClientPool.<ZSetScoreAsync>d__206();
			<ZSetScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ZSetScoreAsync>d__.<>4__this = this;
			<ZSetScoreAsync>d__.key = key;
			<ZSetScoreAsync>d__.member = member;
			<ZSetScoreAsync>d__.<>1__state = -1;
			<ZSetScoreAsync>d__.<>t__builder.Start<RedisClientPool.<ZSetScoreAsync>d__206>(ref <ZSetScoreAsync>d__);
			return <ZSetScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Read``1" />
		// Token: 0x06001658 RID: 5720 RVA: 0x00072F42 File Offset: 0x00071142
		public OperateResult<T> Read<T>() where T : class, new()
		{
			return this.ConnectPoolExecute<T>((RedisClient m) => m.Read<T>());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Write``1(``0)" />
		// Token: 0x06001659 RID: 5721 RVA: 0x00072F6C File Offset: 0x0007116C
		public OperateResult Write<T>(T data) where T : class, new()
		{
			return this.ConnectPoolExecute((RedisClient m) => m.Write<T>(data));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.Read``1" />
		// Token: 0x0600165A RID: 5722 RVA: 0x00072F98 File Offset: 0x00071198
		[DebuggerStepThrough]
		public Task<OperateResult<T>> ReadAsync<T>() where T : class, new()
		{
			RedisClientPool.<ReadAsync>d__209<T> <ReadAsync>d__ = new RedisClientPool.<ReadAsync>d__209<T>();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<RedisClientPool.<ReadAsync>d__209<T>>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.Write``1(``0)" />
		// Token: 0x0600165B RID: 5723 RVA: 0x00072FDC File Offset: 0x000711DC
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync<T>(T data) where T : class, new()
		{
			RedisClientPool.<WriteAsync>d__210<T> <WriteAsync>d__ = new RedisClientPool.<WriteAsync>d__210<T>();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.data = data;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<RedisClientPool.<WriteAsync>d__210<T>>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Save" />
		// Token: 0x0600165C RID: 5724 RVA: 0x00073027 File Offset: 0x00071227
		public OperateResult Save()
		{
			return this.ConnectPoolExecute((RedisClient m) => m.Save());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SaveAsync" />
		// Token: 0x0600165D RID: 5725 RVA: 0x0007304E File Offset: 0x0007124E
		public OperateResult SaveAsync()
		{
			return this.ConnectPoolExecute((RedisClient m) => m.SaveAsync());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadServerTime" />
		// Token: 0x0600165E RID: 5726 RVA: 0x00073075 File Offset: 0x00071275
		public OperateResult<DateTime> ReadServerTime()
		{
			return this.ConnectPoolExecute<DateTime>((RedisClient m) => m.ReadServerTime());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Ping" />
		// Token: 0x0600165F RID: 5727 RVA: 0x0007309C File Offset: 0x0007129C
		public OperateResult Ping()
		{
			return this.ConnectPoolExecute((RedisClient m) => m.Ping());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DBSize" />
		// Token: 0x06001660 RID: 5728 RVA: 0x000730C3 File Offset: 0x000712C3
		public OperateResult<long> DBSize()
		{
			return this.ConnectPoolExecute<long>((RedisClient m) => m.DBSize());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.FlushDB" />
		// Token: 0x06001661 RID: 5729 RVA: 0x000730EA File Offset: 0x000712EA
		public OperateResult FlushDB()
		{
			return this.ConnectPoolExecute((RedisClient m) => m.FlushDB());
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ChangePassword(System.String)" />
		// Token: 0x06001662 RID: 5730 RVA: 0x00073114 File Offset: 0x00071314
		public OperateResult ChangePassword(string password)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.ChangePassword(password));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ReadServerTime" />
		// Token: 0x06001663 RID: 5731 RVA: 0x00073140 File Offset: 0x00071340
		[DebuggerStepThrough]
		public Task<OperateResult<DateTime>> ReadServerTimeAsync()
		{
			RedisClientPool.<ReadServerTimeAsync>d__218 <ReadServerTimeAsync>d__ = new RedisClientPool.<ReadServerTimeAsync>d__218();
			<ReadServerTimeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<DateTime>>.Create();
			<ReadServerTimeAsync>d__.<>4__this = this;
			<ReadServerTimeAsync>d__.<>1__state = -1;
			<ReadServerTimeAsync>d__.<>t__builder.Start<RedisClientPool.<ReadServerTimeAsync>d__218>(ref <ReadServerTimeAsync>d__);
			return <ReadServerTimeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.Ping" />
		// Token: 0x06001664 RID: 5732 RVA: 0x00073184 File Offset: 0x00071384
		[DebuggerStepThrough]
		public Task<OperateResult> PingAsync()
		{
			RedisClientPool.<PingAsync>d__219 <PingAsync>d__ = new RedisClientPool.<PingAsync>d__219();
			<PingAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<PingAsync>d__.<>4__this = this;
			<PingAsync>d__.<>1__state = -1;
			<PingAsync>d__.<>t__builder.Start<RedisClientPool.<PingAsync>d__219>(ref <PingAsync>d__);
			return <PingAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.DBSize" />
		// Token: 0x06001665 RID: 5733 RVA: 0x000731C8 File Offset: 0x000713C8
		[DebuggerStepThrough]
		public Task<OperateResult<long>> DBSizeAsync()
		{
			RedisClientPool.<DBSizeAsync>d__220 <DBSizeAsync>d__ = new RedisClientPool.<DBSizeAsync>d__220();
			<DBSizeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<DBSizeAsync>d__.<>4__this = this;
			<DBSizeAsync>d__.<>1__state = -1;
			<DBSizeAsync>d__.<>t__builder.Start<RedisClientPool.<DBSizeAsync>d__220>(ref <DBSizeAsync>d__);
			return <DBSizeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.FlushDB" />
		// Token: 0x06001666 RID: 5734 RVA: 0x0007320C File Offset: 0x0007140C
		[DebuggerStepThrough]
		public Task<OperateResult> FlushDBAsync()
		{
			RedisClientPool.<FlushDBAsync>d__221 <FlushDBAsync>d__ = new RedisClientPool.<FlushDBAsync>d__221();
			<FlushDBAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<FlushDBAsync>d__.<>4__this = this;
			<FlushDBAsync>d__.<>1__state = -1;
			<FlushDBAsync>d__.<>t__builder.Start<RedisClientPool.<FlushDBAsync>d__221>(ref <FlushDBAsync>d__);
			return <FlushDBAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.ChangePassword(System.String)" />
		// Token: 0x06001667 RID: 5735 RVA: 0x00073250 File Offset: 0x00071450
		[DebuggerStepThrough]
		public Task<OperateResult> ChangePasswordAsync(string password)
		{
			RedisClientPool.<ChangePasswordAsync>d__222 <ChangePasswordAsync>d__ = new RedisClientPool.<ChangePasswordAsync>d__222();
			<ChangePasswordAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ChangePasswordAsync>d__.<>4__this = this;
			<ChangePasswordAsync>d__.password = password;
			<ChangePasswordAsync>d__.<>1__state = -1;
			<ChangePasswordAsync>d__.<>t__builder.Start<RedisClientPool.<ChangePasswordAsync>d__222>(ref <ChangePasswordAsync>d__);
			return <ChangePasswordAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Publish(System.String,System.String)" />
		// Token: 0x06001668 RID: 5736 RVA: 0x0007329C File Offset: 0x0007149C
		public OperateResult<int> Publish(string channel, string message)
		{
			return this.ConnectPoolExecute<int>((RedisClient m) => m.Publish(channel, message));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.Publish(System.String,System.String)" />
		// Token: 0x06001669 RID: 5737 RVA: 0x000732D0 File Offset: 0x000714D0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> PublishAsync(string channel, string message)
		{
			RedisClientPool.<PublishAsync>d__224 <PublishAsync>d__ = new RedisClientPool.<PublishAsync>d__224();
			<PublishAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<PublishAsync>d__.<>4__this = this;
			<PublishAsync>d__.channel = channel;
			<PublishAsync>d__.message = message;
			<PublishAsync>d__.<>1__state = -1;
			<PublishAsync>d__.<>t__builder.Start<RedisClientPool.<PublishAsync>d__224>(ref <PublishAsync>d__);
			return <PublishAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SelectDB(System.Int32)" />
		// Token: 0x0600166A RID: 5738 RVA: 0x00073324 File Offset: 0x00071524
		public OperateResult SelectDB(int db)
		{
			return this.ConnectPoolExecute((RedisClient m) => m.SelectDB(db));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClientPool.SelectDB(System.Int32)" />
		// Token: 0x0600166B RID: 5739 RVA: 0x00073350 File Offset: 0x00071550
		[DebuggerStepThrough]
		public Task<OperateResult> SelectDBAsync(int db)
		{
			RedisClientPool.<SelectDBAsync>d__226 <SelectDBAsync>d__ = new RedisClientPool.<SelectDBAsync>d__226();
			<SelectDBAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<SelectDBAsync>d__.<>4__this = this;
			<SelectDBAsync>d__.db = db;
			<SelectDBAsync>d__.<>1__state = -1;
			<SelectDBAsync>d__.<>t__builder.Start<RedisClientPool.<SelectDBAsync>d__226>(ref <SelectDBAsync>d__);
			return <SelectDBAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600166C RID: 5740 RVA: 0x0007339B File Offset: 0x0007159B
		public override string ToString()
		{
			return string.Format("RedisConnectPool[{0}]", this.redisConnectPool.MaxConnector);
		}

		// Token: 0x04000525 RID: 1317
		private ConnectPool<IRedisConnector> redisConnectPool;
	}
}
